[ { "path": ".clang-format", "content": "---\nLanguage: Cpp\n# BasedOnStyle: Google\nAccessModifierOffset: -1\nAlignAfterOpenBracket: Align\nAlignConsecutiveAssignments: false\nAlignConsecutiveDeclarations: false\nAlignEscapedNewlines: Left\nAlignOperands: true\nAlignTrailingComments: true\nAllowAllParametersOfDeclarationOnNextLine: true\nAllowShortBlocksOnASingleLine: true\nAllowShortCaseLabelsOnASingleLine: false\nAllowShortFunctionsOnASingleLine: All\nAllowShortIfStatementsOnASingleLine: true\nAllowShortLoopsOnASingleLine: true\nAlwaysBreakAfterDefinitionReturnType: None\nAlwaysBreakAfterReturnType: None\nAlwaysBreakBeforeMultilineStrings: true\nAlwaysBreakTemplateDeclarations: Yes\nBinPackArguments: true\nBinPackParameters: true\nBraceWrapping: \n AfterClass: false\n AfterControlStatement: false\n AfterEnum: false\n AfterFunction: false\n AfterNamespace: false\n AfterObjCDeclaration: false\n AfterStruct: false\n AfterUnion: false\n AfterExternBlock: false\n BeforeCatch: false\n BeforeElse: false\n IndentBraces: false\n SplitEmptyFunction: true\n SplitEmptyRecord: true\n SplitEmptyNamespace: true\nBreakBeforeBinaryOperators: None\nBreakBeforeBraces: Attach\nBreakBeforeInheritanceComma: false\nBreakInheritanceList: BeforeColon\nBreakBeforeTernaryOperators: true\nBreakConstructorInitializersBeforeComma: false\nBreakConstructorInitializers: BeforeColon\nBreakAfterJavaFieldAnnotations: false\nBreakStringLiterals: true\nColumnLimit: 80\nCommentPragmas: '^ IWYU pragma:'\nCompactNamespaces: false\nConstructorInitializerAllOnOneLineOrOnePerLine: true\nConstructorInitializerIndentWidth: 4\nContinuationIndentWidth: 4\nCpp11BracedListStyle: true\nDerivePointerAlignment: true\nDisableFormat: false\nExperimentalAutoDetectBinPacking: false\nFixNamespaceComments: true\nForEachMacros: \n - foreach\n - Q_FOREACH\n - BOOST_FOREACH\nIncludeBlocks: Preserve\nIncludeCategories: \n - Regex: '^'\n Priority: 2\n - Regex: '^<.*\\.h>'\n Priority: 1\n - Regex: '^<.*'\n Priority: 2\n - Regex: '.*'\n Priority: 3\nIncludeIsMainRegex: '([-_](test|unittest))?$'\nIndentCaseLabels: true\nIndentPPDirectives: None\nIndentWidth: 2\nIndentWrappedFunctionNames: false\nJavaScriptQuotes: Leave\nJavaScriptWrapImports: true\nKeepEmptyLinesAtTheStartOfBlocks: false\nMacroBlockBegin: ''\nMacroBlockEnd: ''\nMaxEmptyLinesToKeep: 1\nNamespaceIndentation: None\nObjCBinPackProtocolList: Never\nObjCBlockIndentWidth: 2\nObjCSpaceAfterProperty: false\nObjCSpaceBeforeProtocolList: false\nPenaltyBreakAssignment: 2\nPenaltyBreakBeforeFirstCallParameter: 1\nPenaltyBreakComment: 300\nPenaltyBreakFirstLessLess: 120\nPenaltyBreakString: 1000\nPenaltyBreakTemplateDeclaration: 10\nPenaltyExcessCharacter: 1000000\nPenaltyReturnTypeOnItsOwnLine: 200\nPointerAlignment: Left\nRawStringFormats: \n - Language: Cpp\n Delimiters: \n - cc\n - CC\n - cpp\n - Cpp\n - CPP\n - 'c++'\n - 'C++'\n CanonicalDelimiter: ''\n BasedOnStyle: google\n - Language: TextProto\n Delimiters: \n - pb\n - PB\n - proto\n - PROTO\n EnclosingFunctions: \n - EqualsProto\n - EquivToProto\n - PARSE_PARTIAL_TEXT_PROTO\n - PARSE_TEST_PROTO\n - PARSE_TEXT_PROTO\n - ParseTextOrDie\n - ParseTextProtoOrDie\n CanonicalDelimiter: ''\n BasedOnStyle: google\nReflowComments: true\nSortIncludes: true\nSortUsingDeclarations: true\nSpaceAfterCStyleCast: false\nSpaceAfterTemplateKeyword: true\nSpaceBeforeAssignmentOperators: true\nSpaceBeforeCpp11BracedList: false\nSpaceBeforeCtorInitializerColon: true\nSpaceBeforeInheritanceColon: true\nSpaceBeforeParens: ControlStatements\nSpaceBeforeRangeBasedForLoopColon: true\nSpaceInEmptyParentheses: false\nSpacesBeforeTrailingComments: 2\nSpacesInAngles: false\nSpacesInContainerLiterals: true\nSpacesInCStyleCastParentheses: false\nSpacesInParentheses: false\nSpacesInSquareBrackets: false\nStandard: Auto\nTabWidth: 8\nUseTab: Never\n...\n\n" }, { "path": ".clang-tidy", "content": "---\nChecks: 'clang-diagnostic-*,clang-analyzer-*,google-*'\nWarningsAsErrors: ''\nHeaderFilterRegex: ''\nAnalyzeTemporaryDtors: false\nFormatStyle: none\nUser: brenden\nCheckOptions: \n - key: google-build-namespaces.HeaderFileExtensions\n value: ',h,hh,hpp,hxx'\n - key: google-global-names-in-headers.HeaderFileExtensions\n value: ',h,hh,hpp,hxx'\n - key: google-readability-braces-around-statements.ShortStatementLines\n value: '1'\n - key: google-readability-function-size.BranchThreshold\n value: '4294967295'\n - key: google-readability-function-size.LineThreshold\n value: '4294967295'\n - key: google-readability-function-size.NestingThreshold\n value: '4294967295'\n - key: google-readability-function-size.ParameterThreshold\n value: '4294967295'\n - key: google-readability-function-size.StatementThreshold\n value: '800'\n - key: google-readability-function-size.VariableThreshold\n value: '4294967295'\n - key: google-readability-namespace-comments.ShortNamespaceLines\n value: '10'\n - key: google-readability-namespace-comments.SpacesBeforeComments\n value: '2'\n - key: google-runtime-int.SignedTypePrefix\n value: int\n - key: google-runtime-int.TypeSuffix\n value: ''\n - key: google-runtime-int.UnsignedTypePrefix\n value: uint\n - key: google-runtime-references.WhiteListTypes\n value: ''\n - key: modernize-loop-convert.MaxCopySize\n value: '16'\n - key: modernize-loop-convert.MinConfidence\n value: reasonable\n - key: modernize-loop-convert.NamingStyle\n value: CamelCase\n - key: modernize-pass-by-value.IncludeStyle\n value: llvm\n - key: modernize-replace-auto-ptr.IncludeStyle\n value: llvm\n - key: modernize-use-nullptr.NullMacros\n value: 'NULL'\n...\n\n" }, { "path": ".dockerignore", "content": "Dockerfile\n.dockerignore\n\n# Ignore SCM/CI related stuff\n.github/\n.git/\n.gitlab-ci.yml\n\n**/.DS_Store\n**/*~\n**/.*.swp\nDoxyfile\npatches/\ndoc/conky.1\nREADME\nbuild*/\ndoc/*.html\n\nMakefile\nCMakeCache.txt\nCMakeFiles\ndata/convertconf.h\ndata/defconfig.h\nlua/libcairo-orig.c\nlua/libcairo.c\nlua/libimlib2.c\n*.so\n*.a\n/config.h\n\n# Ignore vscode stuff\n.vscode\n*.code-workspace\n\n# Ignore tests\ntests/\n" }, { "path": ".editorconfig", "content": "root = true\n\n[*]\nend_of_line = lf\ninsert_final_newline = true\nindent_style = space\nindent_size = 2\n" }, { "path": ".envrc", "content": "use flake\n" }, { "path": ".git-blame-ignore-revs", "content": "# Run this command to always ignore formatting commits in `git blame`\n# git config blame.ignoreRevsFile .git-blame-ignore-revs\n\n# Following commits only reformat/cleanup code and can be ignored when tracking\n# down regressions and introduced bugs:\n\n### Clarifying licensing (SVN@904)\n# Updates license headers\n27b4c8550cfae4fd0f2169962e33f4907a8e7d71\n\n### Reformatted all code (SVN@1007)\n3d26a4880e92df2c6004d85c1be458e35c6bfc3a\n\n# Spelling fixes\nb62e1158300f0644b304f2f8b7e8105ba09073b3\n\n### outsource the whole template object machinery\n# Moves template variables code from core.c into template.c\nff199355f66216600c4bdc6bec4743afe5b61470\n\n### Add formatting/static analysis (#486)\n# Large cleanup of codebase that fixed indentation in most files\neebc8c653b34eb946d23ceb913ed5d69cc22f10e\n\n### Build improvements: clang-tidy, sonar, Dockerfile. (#488)\n# Touches most files with minor changes (NULL -> nullptr)\n4b92556fca9cbede3cbac4112f0a24b554390099\n\n### Use clang-format\n# Applies clang-format formatting\n033508a93e6b0440ddbd2376c1e97b69e3308687\n\n### Move X11 stuff from conky.cc to display-x11\n281097a2a562ef58e5604a3519f739c715ba5410\n\n### Get rid of silly `if (not ...` expressions (#713)\n3a3092902ee8a5fda71996d264f981b98375c6a3\n\n### Fix docbook2x handling.\n# Large diff, affects only docbook2x which is no longer used\nc6ad28074af3ec1bb4b3cc052df58062ce2a7c9b\n\n### Fix MAINTAINER_MODE (-Wall -Werror -Wpedantic) (#714)\n# Large diff, minor refactoring changes\n9af6fa7903c5cb6f05614deac23373d4d0cf5959\n\n### Refactor docs, make a new website\n# Large diff, no changes affecting code\n47ad3f9982baea4069a5c37ffdb2e1523e504f18\n\n### Fix issues building without BUILD_ARGB flag\n# Changes a lot of indentations in x11.cc\nf6d42c5a69fed134a8b4ed0602c892f6f7b6e242\n### Fix DependentOptions splitting arguments on spaces\n# Again, indentation changes in x11.cc\ncbebe447078e28c50957d568303f42d6b8aae126\n\n### Cleanup build flags, global namespace and includes (#1841)\n# Large refactor of global namespace\n# Includes changes to functionality so it can't be ignored:\n# color parsing, text alignment, output registration\n# 6adf6b9dd4d368640bf7ef57f3e6199d83154d78\n\n### Move sources into appropriate subdirectories (#2119)\n# Performed no changes to the source files, only moved them. Child commit\n# addressed the bugs caused by the move, to separate renames from changes.\n342f07b8ca101e0c4ef5c75346033c4df241d16d\nae8f1fa8472d6c3a31b4a09be4d19568a3f3f23e\n" }, { "path": ".github/FUNDING.yml", "content": "# These are supported funding model platforms\n\ngithub: brndnmtthws\n" }, { "path": ".github/ISSUE_TEMPLATE/bug_report.yml", "content": "name: 🐞 Bug Report\ndescription: 'File a bug report: crashes, unexpected behaviour, and other errors go here.'\ntitle: '[Bug]: '\nlabels: ['bug', 'triage']\nbody:\n - type: markdown\n attributes:\n value: |\n If you haven't done so already, please take a moment to search the [existing issues](https://github.com/brndnmtthws/conky/issues) to see if this has been previously reported. If not, carry on.\n\n Thanks for taking the time to fill out this bug report!\n - type: textarea\n id: what-happened\n attributes:\n label: What happened?\n description: >\n Describe the problem, what you expected to happen, and any other\n relevant info. You can attach logs, stack traces, and config below. If\n required, include screenshots here which demonstrate the problem.\n placeholder: Here's what happened\n validations:\n required: true\n - type: input\n id: version\n attributes:\n label: Version\n description: What version of Conky are you running?\n validations:\n required: true\n - type: dropdown\n id: os\n validations:\n required: true\n attributes:\n label: Which OS/distro are you seeing the problem on?\n options:\n - Ubuntu\n - Fedora\n - Debian\n - Arch Linux\n - Gentoo\n - Linux (other)\n - macOS\n - type: textarea\n id: config\n attributes:\n label: Conky config\n description: Paste your Conky config here if it's relevant.\n render: Lua\n - type: markdown\n attributes:\n value: |\n ## Getting a stack trace\n\n If you are reporting a crash, please attach a stack trace below.\n\n To create one with `gdb`, try the following steps:\n\n ```shell\n # Start 'conky'\n $ gdb conky\n\n # Run 'conky' with a config.\n (gdb) run -c ~/.your_conky.conf\n\n # Wait for a crash to occur, then run this.\n (gdb) bt full\n\n # ... stack trace output here ...\n ```\n\n Here are some additional resources on obtaining stack traces:\n - [Arch Linux Wiki](https://wiki.archlinux.org/index.php/Debug_-_Getting_Traces)\n - [Ubuntu Wiki](https://wiki.ubuntu.com/DebuggingProgramCrash)\n - [AskUbuntu - Where do I find core dump files, and how do I view and analyze the backtrace (stack trace) in one?](https://askubuntu.com/a/1349048)\n - [Julia Evans - How to get a core dump for a segfault on Linux](https://jvns.ca/blog/2018/04/28/debugging-a-segfault-on-linux/)\n - [GDB Documentation](https://sourceware.org/gdb/current/onlinedocs/gdb/)\n - [lldb Documentation](https://lldb.llvm.org/use/tutorial.html)\n - type: textarea\n id: stacktrace\n attributes:\n label: Stack trace\n description: Paste your stacktrace here if you have one.\n render: GDB\n - type: textarea\n id: logs\n attributes:\n label: Relevant log output\n description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.\n render: Shell\n" }, { "path": ".github/ISSUE_TEMPLATE/config.yml", "content": "blank_issues_enabled: true\ncontact_links:\n - name: 🙏 General questions & help\n url: https://github.com/brndnmtthws/conky/discussions/categories/q-a\n about: Please ask and answer general questions using GitHub Discussions\n - name: 💡 New ideas and feature requests\n url: https://github.com/brndnmtthws/conky/discussions/categories/ideas\n about: Request and discuss enhancements using GitHub Discussions\n" }, { "path": ".github/dependabot.yml", "content": "# Set update schedule for GitHub Actions\n\nversion: 2\nupdates:\n # Maintain dependencies for actions\n - package-ecosystem: 'github-actions'\n directory: '/'\n schedule:\n interval: 'weekly'\n groups:\n actions:\n patterns:\n - '*'\n\n # Maintain dependencies for web docs/npm\n - package-ecosystem: 'npm'\n directory: '/web'\n schedule:\n interval: 'weekly'\n groups:\n web-deps:\n patterns:\n # Group all the web deps together to keep the PR spam down\n - '*'\n" }, { "path": ".github/instructions/cmake-review.instructions.md", "content": "---\napplyTo: 'CMakeLists.txt,cmake/**/*.cmake,tests/CMakeLists.txt,src/CMakeLists.txt,lua/CMakeLists.txt,data/CMakeLists.txt,doc/CMakeLists.txt,extras/CMakeLists.txt,3rdparty/CMakeLists.txt'\nexcludeAgent: 'coding-agent'\n---\n\n# Conky Build-System Review Instructions\n\nPrioritize build reproducibility and CI parity.\n\nFocus review comments on:\n\n- Option defaults and interactions (`MAINTAINER_MODE`, `BUILD_TESTING`, `CHECK_CODE_QUALITY`, `CODE_COVERAGE`) that may change expected developer or CI behavior.\n- Platform/compiler conditionals that could break Linux/macOS matrix builds.\n- Dependency/linking changes that risk optional feature regressions.\n- New targets/commands that are not wired into existing workflows or documented usage.\n\nValidation expectations:\n\n- Build paths should remain compatible with `cmake . -B build -G Ninja -DMAINTAINER_MODE=ON`.\n- Test execution should remain compatible with `ctest --output-on-failure` from `build/`.\n- Format-related guidance should align with available targets (`clang-format`, `check-clang-format`) and their configuration preconditions.\n\nRaise comments when CMake changes alter cache variable semantics without migration notes or clear rationale.\n" }, { "path": ".github/instructions/cpp-review.instructions.md", "content": "---\napplyTo: 'src/**/*.cc,src/**/*.hh,src/**/*.hpp,src/**/*.h,src/**/*.cpp,tests/**/*.cc,tests/**/*.hh,tests/**/*.hpp,tests/**/*.h,lua/**/*.cc,lua/**/*.hh,lua/**/*.hpp,lua/**/*.h'\nexcludeAgent: 'coding-agent'\n---\n\n# Conky C/C++ Review Instructions\n\nPrioritize behavioral correctness, regressions, and runtime safety over style-only feedback.\n\nFocus review comments on:\n\n- Changes to text object registration (for example `OBJ`, `OBJ_ARG`, `OBJ_IF`, and `OBJ_IF_ARG` in `construct_text_object()` in `src/core.cc`) and update logic (`update_cb` + `conky::callback_handle`) that could break refresh cadence, caching, or responsiveness.\n- Backend behavior across output modes (`display_output_base` descendants), especially graceful degradation for ncurses and HTTP outputs.\n- Platform-guarded logic under `src/data/os/` and tests that should mirror implementation `#ifdef` boundaries.\n- Lifetime/ownership bugs, null dereferences, unchecked conversions, out-of-bounds access, and unintended copies in hot paths.\n\nTesting expectations:\n\n- New behavior should have or update tests in `tests/test-*.cc`.\n- Encourage focused test runs with `./build/tests/test-conky \"\"` and full verification with `ctest --test-dir build --output-on-failure`.\n- If behavior changed but no test changed, ask for justification.\n\nDo not request purely stylistic changes already enforced by clang-format unless readability or correctness is impacted.\n" }, { "path": ".github/instructions/workflow-review.instructions.md", "content": "---\napplyTo: '.github/workflows/**/*.yml,.github/workflows/**/*.yaml,.github/scripts/**/*.sh,.github/scripts/**/*.bash,Dockerfile,tests/dockerfiles/**'\nexcludeAgent: 'coding-agent'\n---\n\n# Conky CI/Release Review Instructions\n\nPrioritize signal quality and release safety.\n\nFocus review comments on:\n\n- Steps that could mask failures (missing `set -e`, ignored exit codes, or removed test stages).\n- Drift from project CI expectations: configure, build, and run tests (`ctest --output-on-failure`) on supported matrices.\n- Cache key changes that risk stale artifacts or ineffective caching.\n- Changes affecting release artifacts (AppImage, Docker, checksums, signing) and versioning correctness.\n- Security concerns in actions usage (unpinned third-party actions, unsafe token exposure, or over-broad permissions).\n\nRequire explicit rationale when reducing matrix coverage or disabling optional feature combinations that currently run in CI.\n" }, { "path": ".github/labeler.yml", "content": "documentation:\n - changed-files:\n - any-glob-to-any-file:\n - doc/**/*\n - data/conky*.conf\n\nextras:\n - changed-files:\n - any-glob-to-any-file:\n - extras/**/*\n\nsources:\n - changed-files:\n - any-glob-to-any-file:\n - src/**/*\n\ntests:\n - changed-files:\n - any-glob-to-any-file:\n - tests/**/*\n\nweb:\n - changed-files:\n - any-glob-to-any-file:\n - web/**/*\n\njavascript:\n - changed-files:\n - any-glob-to-any-file:\n - web/**/*.tsx\n - web/**/*.jsx\n - web/**/*.ts\n - web/**/*.js\n\nappimage:\n - changed-files:\n - any-glob-to-any-file:\n - appimage/*\n - appimage/**/*\n\n3rdparty:\n - changed-files:\n - any-glob-to-any-file:\n - 3rdparty/**/*\n\ngh-actions:\n - changed-files:\n - any-glob-to-any-file:\n - .github/workflows/*\n - .github/workflows/**/*\n - .github/labeler.yml\n - .github/pull_request_template.md\n\ndependencies:\n - changed-files:\n - any-glob-to-any-file:\n - web/package-lock.json\n - cmake/ConkyPlatformChecks.cmake\n\naudio:\n - changed-files:\n - any-glob-to-any-file:\n - src/data/audio/**/*\n\npower:\n - changed-files:\n - any-glob-to-any-file:\n - src/data/hardware/apcupsd.cc\n - src/data/hardware/apcupsd.h\n - src/data/hardware/bsdapm.cc\n - src/data/hardware/bsdapm.h\n - src/data/hardware/smapi.cc\n - src/data/hardware/smapi.h\n\n'display: console':\n - changed-files:\n - any-glob-to-any-file:\n - src/output/display-console.cc\n - src/output/display-console.hh\n'display: file':\n - changed-files:\n - any-glob-to-any-file:\n - src/output/display-file.cc\n - src/output/display-file.hh\n'display: http':\n - changed-files:\n - any-glob-to-any-file:\n - src/output/display-http.cc\n - src/output/display-http.hh\n'display: ncurses':\n - changed-files:\n - any-glob-to-any-file:\n - src/output/nc.cc\n - src/output/nc.h\n - src/output/display-ncurses.cc\n - src/output/display-ncurses.hh\n'display: wayland':\n - changed-files:\n - any-glob-to-any-file:\n - src/wl_protocols/**/*\n - src/output/wl.cc\n - src/output/wl.h\n - src/output/display-wayland.cc\n - src/output/display-wayland.hh\n'display: x11':\n - changed-files:\n - any-glob-to-any-file:\n - src/output/*x11*.cc\n - src/output/*x11*.h\n - src/output/*x11*.hh\n\n'build system':\n - changed-files:\n - any-glob-to-any-file:\n - 'CMakeLists.txt'\n - 'cmake/**/*'\n\ncairo:\n - changed-files:\n - any-glob-to-any-file:\n - 'lua/*cairo*'\n\n'disk io':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/hardware/diskio.cc\n - src/data/hardware/diskio.h\n\n'sensors':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/hardware/hddtemp.cc\n - src/data/hardware/hddtemp.h\n - src/data/hardware/i8k.cc\n - src/data/hardware/i8k.h\n - src/data/hardware/sony.cc\n - src/data/hardware/sony.h\n\ncpu:\n - changed-files:\n - any-glob-to-any-file:\n - src/data/hardware/cpu.cc\n - src/data/hardware/cpu.h\n - src/data/proc.cc\n - src/data/proc.h\n - src/data/top.cc\n - src/data/top.h\n\nlua:\n - changed-files:\n - any-glob-to-any-file:\n - lua/**/*\n - src/lua/**/*\n\n'os: linux':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/os/linux.cc\n - src/data/os/linux.h\n\n'os: dragonfly':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/os/dragonfly.cc\n - src/data/os/dragonfly.h\n\n'os: freebsd':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/os/freebsd.cc\n - src/data/os/freebsd.h\n\n'os: haiku':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/os/haiku.cc\n - src/data/os/haiku.h\n\n'os: netbsd':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/os/netbsd.cc\n - src/data/os/netbsd.h\n\n'os: openbsd':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/os/openbsd.cc\n - src/data/os/openbsd.h\n\n'os: solaris':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/os/solaris.cc\n - src/data/os/solaris.h\n\n'os: macos':\n - changed-files:\n - any-glob-to-any-file:\n - src/data/os/darwin_sip.h\n - src/data/os/darwin.h\n - src/data/os/darwin.mm\n\n'mouse events':\n - changed-files:\n - any-glob-to-any-file:\n - src/mouse-events.cc\n - src/mouse-events.h\n\nnetworking:\n - changed-files:\n - any-glob-to-any-file:\n - src/data/network/**/*\n\nmail:\n - changed-files:\n - any-glob-to-any-file:\n - src/data/network/mail.cc\n - src/data/network/mail.h\n\ncalendar:\n - changed-files:\n - any-glob-to-any-file:\n - src/data/network/ical.cc\n - src/data/network/ical.h\n\nnvidia:\n - changed-files:\n - any-glob-to-any-file:\n - src/data/hardware/nvidia.cc\n - src/data/hardware/nvidia.h\n\nrendering:\n - changed-files:\n - any-glob-to-any-file:\n - src/output/gui.cc\n - src/output/gui.h\n - src/specials.cc\n - src/specials.h\n\ntext:\n - changed-files:\n - any-glob-to-any-file:\n - src/content/**/*\n" }, { "path": ".github/pull_request_template.md", "content": "# Checklist\n- [ ] I have described the changes\n- [ ] I have linked to any relevant GitHub issues, if applicable\n- [ ] Documentation in `doc/` has been updated\n- [ ] All new code is licensed under GPLv3\n\n## Description\n\n* Describe the changes, why they were necessary, etc\n* Describe how the changes will affect existing behaviour.\n* Describe how you tested and validated your changes.\n* Include any relevant screenshots/evidence demonstrating that the changes work and have been tested.\n" }, { "path": ".github/release.yml", "content": "changelog:\n categories:\n - title: 🏕 Features\n labels:\n - feature\n - title: 🧪 Improvements\n labels:\n - enhancement\n - title: 🐞 Bug fixes\n labels:\n - bug\n - regression\n - title: 🎛️ Miscellaneous\n labels:\n - '*'\n exclude:\n labels:\n - dependencies\n - bug\n - regression\n - feature\n - enhancement\n - title: 👒 Dependencies\n labels:\n - dependencies\n" }, { "path": ".github/scripts/docker-build.bash", "content": "#!/usr/bin/env bash\nset -e\n\nDH_USERNAME=\"${DOCKERHUB_USERNAME:-conky}\"\nDOCKERHUB_IMAGE_ID=$DH_USERNAME/$IMAGE_NAME\n\n# Change all uppercase to lowercase\nDOCKERHUB_IMAGE_ID=$(echo $DOCKERHUB_IMAGE_ID | tr '[A-Z]' '[a-z]')\n\n# Only build amd64 on PRs, build all platforms on main. The arm builds\n# take far too long.\nimage_platforms=\"--platform linux/amd64\"\npush_image=\"\"\ncache_tag=\"pr-cache\"\nimage_tags=()\n\n# Strip git ref prefix from version\nVERSION_TAG=$(echo $GITHUB_REF | sed -e 's,.*/\\(.*\\),\\1,')\n\n# Strip \"v\" prefix from tag name\nif [[ \"$GITHUB_REF\" == refs/tags/* ]]; then\n VERSION_TAG=$(echo $VERSION_TAG | sed -e 's/^v//')\nfi\n\nimage_tags+=(\"--tag\" \"$DOCKERHUB_IMAGE_ID:$VERSION_TAG\")\n\n# tag as latest on releases\nif [[ \"$RELEASE\" == ON ]]; then\n image_tags+=(\"--tag\" \"$DOCKERHUB_IMAGE_ID:latest\")\nfi\n\n# Only push on main\nif [[ \"$GITHUB_REF\" == refs/heads/main ]]; then\n push_image=\"--push\"\n image_platforms=\"--platform linux/arm/v7,linux/arm64/v8,linux/amd64\"\n cache_tag=\"main-cache\"\nfi\n\n# Only write to cache if credentials are available\nif [[ -z \"$DOCKERHUB_TOKEN\" ]]; then\n write_cache=\"\"\nelse\n write_cache=\"--cache-to=type=registry,ref=$DOCKERHUB_IMAGE_ID:$cache_tag,mode=max\"\nfi\n\ndocker buildx build \\\n ${push_image} \\\n ${image_platforms} \\\n --cache-from=type=registry,ref=$DOCKERHUB_IMAGE_ID:$cache_tag \\\n ${write_cache} \\\n \"${image_tags[@]}\" \\\n .\n" }, { "path": ".github/scripts/setup-sccache.sh", "content": "#!/bin/sh\n\nexport SCCACHE_VERSION=\"${SCCACHE_VERSION:=0.9.1}\"\n\nexport sccache_arch=\"x86_64\"\nif [ \"$RUNNER_ARCH\" = \"X86\" ]; then\n export sccache_arch=\"i686\"\nelif [ \"$RUNNER_ARCH\" = \"X64\" ]; then\n export sccache_arch=\"x86_64\"\nelif [ \"$RUNNER_ARCH\" = \"ARM\" ]; then\n export sccache_arch=\"armv7\"\nelif [ \"$RUNNER_ARCH\" = \"ARM64\" ]; then\n export sccache_arch=\"aarch64\"\nfi\n\ninstall_sccache() {\n export sccache_archive=\"sccache-v$SCCACHE_VERSION-$sccache_arch-$sccache_os\"\n export sccache_url=\"https://github.com/mozilla/sccache/releases/download/v$SCCACHE_VERSION/$sccache_archive.tar.gz\"\n\n echo \"Downloading $sccache_url...\"\n if ! wget -q \"$sccache_url\"; then\n echo \"Can't download $sccache_url.\" >2\n exit 1\n fi\n echo \"Extracting $sccache_archive.tar.gz...\"\n if ! tar -xzf \"$sccache_archive.tar.gz\" >/dev/null; then\n echo \"Can't extract $sccache_archive.tar.gz\" >2\n exit 1\n fi\n chmod +x \"$sccache_archive/sccache\"\n sudo cp \"$sccache_archive/sccache\" \"/usr/local/bin/sccache\"\n rm -rf \"$sccache_archive.tar.gz\"\n rm -rf \"$sccache_archive\"\n}\n\nexport sccache_os=\"unknown-linux-musl\"\nif [ \"$RUNNER_OS\" = \"Linux\" ]; then\n export sccache_os=\"unknown-linux-musl\"\n if [ \"$RUNNER_ARCH\" = \"ARM\" ]; then\n export sccache_os=\"unknown-linux-musleabi\"\n fi\n if ! install_sccache; then\n echo \"Unable to install sccache!\" >2\n exit 1\n fi\nelif [ \"$RUNNER_OS\" = \"macOS\" ]; then\n export sccache_os=\"apple-darwin\"\n if ! install_sccache; then\n echo \"Unable to install sccache!\" >2\n exit 1\n fi\nelif [ \"$RUNNER_OS\" = \"Windows\" ]; then\n export sccache_os=\"pc-windows-msvc\"\n if ! install_sccache; then\n echo \"Unable to install sccache!\" >2\n exit 1\n fi\nfi\n\necho \"sccache installed.\"\n\n# Configure\nmkdir $HOME/.sccache\necho \"SCCACHE_DIR=$HOME/.sccache\" >>$GITHUB_ENV\nif [ \"$RUNNER_DEBUG\" = \"1\" ]; then\n echo \"Running with debug output; cached binary artifacts will be ignored to produce a cleaner build\"\n echo \"SCCACHE_RECACHE=true\" >>$GITHUB_ENV\nfi\n\necho \"sccache configured.\"\n" }, { "path": ".github/workflows/build-and-test-linux.yaml", "content": "name: Build and test on Linux\non:\n push:\n branches:\n - main\n paths-ignore:\n - web/**\n - doc/**\n pull_request:\n branches:\n - main\n paths-ignore:\n - web/**\n - doc/**\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\nenv:\n SCCACHE_VERSION: '0.9.1'\n\njobs:\n build:\n strategy:\n matrix:\n os:\n - ubuntu-22.04\n - ubuntu-24.04\n x11: [ON, OFF]\n wayland: [ON, OFF]\n compiler:\n - clang\n - gcc\n runs-on: ${{ matrix.os }}\n steps:\n - run: sudo apt-get -qq update\n - name: Install dependencies\n run: |\n sudo apt-get install -yqq --no-install-recommends \\\n audacious-dev \\\n cmake \\\n gawk \\\n gperf \\\n lcov \\\n libaudclient-dev \\\n libcairo2-dev \\\n libpango1.0-dev \\\n libcurl4-gnutls-dev \\\n libdbus-glib-1-dev \\\n libfreetype-dev \\\n libfreetype6-dev \\\n libstdc++6 \\\n libglib2.0-dev \\\n libical-dev \\\n libimlib2-dev \\\n libircclient-dev \\\n libiw-dev \\\n liblua5.3-dev \\\n libmicrohttpd-dev \\\n libmysqlclient-dev \\\n libpulse-dev \\\n librsvg2-dev \\\n libsystemd-dev \\\n libwayland-bin \\\n libwayland-dev \\\n libx11-dev \\\n libxdamage-dev \\\n libxext-dev \\\n libxft-dev \\\n libxinerama-dev \\\n libxml2-dev \\\n libxmmsclient-dev \\\n libxnvctrl-dev \\\n ncurses-dev \\\n ninja-build \\\n wayland-protocols\n - name: Install clang and libc++\n if: matrix.compiler == 'clang'\n run: |\n sudo apt-get install -yqq --no-install-recommends \\\n clang \\\n libc++-dev \\\n libc++abi-dev\n - name: Install gcc\n if: matrix.compiler == 'gcc'\n run: |\n sudo apt-get install -yqq --no-install-recommends \\\n gcc \\\n g++\n - name: Checkout\n uses: actions/checkout@v5\n - name: Install sccache\n run: .github/scripts/setup-sccache.sh\n - name: Load cached compilation artifacts\n id: compiler-cache\n uses: actions/cache@v4\n with:\n path: '${{ env.SCCACHE_DIR }}'\n key: sccache-${{ matrix.os }}-${{ matrix.x11 }}-${{ matrix.wayland }}-${{ matrix.compiler }}\n restore-keys: |\n sccache-${{ matrix.os }}-${{ matrix.x11 }}-${{ matrix.wayland }}-${{ matrix.compiler }}\n sccache-${{ matrix.os }}-${{ matrix.x11 }}-${{ matrix.wayland }}\n sccache-${{ matrix.os }}-${{ matrix.x11 }}\n sccache-${{ matrix.os }}\n - name: Configure with CMake\n run: |\n set -x # show the commands we're running\n [[ \"${{ matrix.compiler }}\" == \"clang\"* ]] && CC=clang\n [[ \"${{ matrix.compiler }}\" == \"clang\"* ]] && CXX=clang++\n\n [[ \"${{ matrix.compiler }}\" == \"gcc\"* ]] && CC=gcc\n [[ \"${{ matrix.compiler }}\" == \"gcc\"* ]] && CXX=g++\n\n\n # Enable librsvg by default, disable for older versions of Ubuntu\n # because we need librsvg>=2.52\n RSVG_ENABLED=ON\n [[ \"${{ matrix.os }}\" == \"ubuntu-20.04\"* ]] && RSVG_ENABLED=OFF\n\n # Reset sccache statistics\n sccache --zero-stats\n\n cmake . -B build -G Ninja \\\n -DBUILD_AUDACIOUS=ON \\\n -DBUILD_HTTP=ON \\\n -DBUILD_ICAL=ON \\\n -DBUILD_ICONV=ON \\\n -DBUILD_IRC=ON \\\n -DBUILD_IRC=ON \\\n -DBUILD_JOURNAL=ON \\\n -DBUILD_LUA_CAIRO=ON \\\n -DBUILD_LUA_CAIRO_XLIB=ON \\\n -DBUILD_LUA_IMLIB2=ON \\\n -DBUILD_LUA_RSVG=${RSVG_ENABLED} \\\n -DBUILD_LUA_TEXT=ON \\\n -DBUILD_MYSQL=ON \\\n -DBUILD_NVIDIA=ON \\\n -DBUILD_PULSEAUDIO=ON \\\n -DBUILD_CURL=ON \\\n -DBUILD_RSS=ON \\\n -DBUILD_WLAN=ON \\\n -DBUILD_WAYLAND=${{ matrix.wayland }}\\\n -DBUILD_X11=${{ matrix.x11 }} \\\n -DBUILD_XMMS2=ON \\\n -DCMAKE_C_COMPILER=$CC \\\n -DCMAKE_CXX_COMPILER=$CXX \\\n -DMAINTAINER_MODE=ON\n - name: Compile\n run: cmake --build build\n - name: Show sccache stats\n run: sccache --show-stats\n - name: Test\n working-directory: build\n run: ctest --output-on-failure\n" }, { "path": ".github/workflows/build-and-test-macos.yaml", "content": "name: Build and test on macOS\non:\n push:\n branches:\n - main\n paths-ignore:\n - web/**\n - doc/**\n pull_request:\n branches:\n - main\n paths-ignore:\n - web/**\n - doc/**\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\nenv:\n SCCACHE_VERSION: '0.9.1'\n\njobs:\n build:\n env:\n HOMEBREW_NO_INSTALL_UPGRADE: 1\n HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1\n strategy:\n matrix:\n os:\n - macos-latest\n runs-on: ${{ matrix.os }}\n steps:\n - name: Install dependencies\n run: |\n brew install --force \\\n curl \\\n freetype \\\n gettext \\\n gperf \\\n imlib2 \\\n lcov \\\n librsvg \\\n libxfixes \\\n libxft \\\n libxi \\\n libxinerama \\\n libxml2 \\\n lua \\\n ninja \\\n pkg-config \\\n || true # Ignore errors\n - name: Checkout\n uses: actions/checkout@v5\n - name: Configure sccache\n run: .github/scripts/setup-sccache.sh\n - name: Load cached compilation artifacts\n id: compiler-cache\n uses: actions/cache@v4\n with:\n path: '${{ env.SCCACHE_DIR }}'\n key: sccache-${{ matrix.os }}\n restore-keys: |\n sccache-${{ matrix.os }}\n sccache-\n - name: Configure with CMake\n run: |\n # Reset sccache statistics\n sccache --zero-stats\n\n cmake . -B build -G Ninja \\\n -DMAINTAINER_MODE=ON \\\n -DBUILD_WAYLAND=OFF \\\n -DBUILD_RSS=ON \\\n -DBUILD_CURL=ON\n - name: Compile\n run: cmake --build build\n - name: Show sccache stats\n run: sccache --show-stats\n - name: Test\n working-directory: build\n run: ctest --output-on-failure\n" }, { "path": ".github/workflows/codeql.yml", "content": "name: 'CodeQL'\n\non:\n schedule:\n - cron: '20 2 * * 0'\n\njobs:\n analyze:\n name: Analyze\n runs-on: ubuntu-latest\n permissions:\n actions: read\n contents: read\n security-events: write\n\n strategy:\n fail-fast: false\n matrix:\n language: ['cpp', 'javascript', 'python']\n # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]\n # Use only 'java' to analyze code written in Java, Kotlin or both\n # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both\n # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support\n\n steps:\n - run: sudo apt-get -qq update\n - name: Install dependencies\n if: matrix.language == 'cpp'\n run: |\n sudo apt-get install -yqq --no-install-recommends \\\n audacious-dev \\\n cmake \\\n gawk \\\n gperf \\\n lcov \\\n libaudclient-dev \\\n libc++-14-dev \\\n libc++abi-14-dev \\\n libcairo2-dev \\\n libcurl4-gnutls-dev \\\n libdbus-glib-1-dev \\\n libfreetype-dev \\\n libfreetype6-dev \\\n libstdc++6 \\\n libglib2.0-dev \\\n libical-dev \\\n libimlib2-dev \\\n libircclient-dev \\\n libiw-dev \\\n liblua5.3-dev \\\n libmicrohttpd-dev \\\n libmysqlclient-dev \\\n libpulse-dev \\\n librsvg2-dev \\\n libsystemd-dev \\\n libwayland-bin \\\n libwayland-dev \\\n libx11-dev \\\n libxdamage-dev \\\n libxext-dev \\\n libxft-dev \\\n libxinerama-dev \\\n libxml2-dev \\\n libxmmsclient-dev \\\n libxnvctrl-dev \\\n ncurses-dev \\\n ninja-build \\\n wayland-protocols\n - name: Checkout repository\n uses: actions/checkout@v5\n\n # Initializes the CodeQL tools for scanning.\n - name: Initialize CodeQL\n uses: github/codeql-action/init@v3\n with:\n languages: ${{ matrix.language }}\n # If you wish to specify custom queries, you can do so here or in a config file.\n # By default, queries listed here will override any specified in a config file.\n # Prefix the list here with \"+\" to use these queries and those in the config file.\n # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs\n # queries: security-extended,security-and-quality\n\n # Autobuild attempts to build any compiled languages (C/C++, C#, Go, or Java).\n # If this step fails, then you should remove it and run the build manually (see below)\n - name: Autobuild\n uses: github/codeql-action/autobuild@v3\n\n - name: Perform CodeQL Analysis\n uses: github/codeql-action/analyze@v3\n with:\n category: '/language:${{matrix.language}}'\n" }, { "path": ".github/workflows/docker.yaml", "content": "name: Docker\n\non:\n push:\n branches:\n - main\n paths-ignore:\n - web/**\n - doc/**\n # Publish `v1.2.3` tags as releases.\n tags:\n - v*\n\n pull_request:\n branches:\n - main\n paths-ignore:\n - web/**\n - doc/**\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\njobs:\n docker-buildx:\n env:\n IMAGE_NAME: conky\n DOCKER_BUILDKIT: 1\n DOCKERHUB_USERNAME: brndnmtthws\n DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}\n runs-on: ubuntu-latest\n steps:\n - name: Checkout\n uses: actions/checkout@v5\n - name: Set up QEMU\n uses: docker/setup-qemu-action@v3\n - name: Set up Docker Buildx\n id: buildx\n uses: docker/setup-buildx-action@v3\n - name: Login to Docker Hub\n uses: docker/login-action@v3\n if: ${{ env.DOCKERHUB_TOKEN != '' }}\n with:\n username: ${{ env.DOCKERHUB_USERNAME }}\n password: ${{ secrets.DOCKERHUB_TOKEN }}\n - name: Build and push Docker image\n env:\n RELEASE: \"${{ startsWith(github.ref, 'refs/tags/') && 'ON' || 'OFF' }}\"\n GITHUB_REF: ${{ github.ref }}\n run: .github/scripts/docker-build.bash\n" }, { "path": ".github/workflows/labeler.yml", "content": "name: 'Pull Request Labeler'\non:\n - pull_request_target\n\njobs:\n triage:\n permissions:\n contents: read\n pull-requests: write\n runs-on: ubuntu-latest\n steps:\n - name: Checkout\n uses: actions/checkout@v5\n - name: Run labeler\n uses: actions/labeler@v6\n with:\n sync-labels: true\n repo-token: '${{ secrets.GITHUB_TOKEN }}'\n" }, { "path": ".github/workflows/nix.yaml", "content": "name: 'Nix build'\non:\n push:\n branches:\n - main\n paths-ignore:\n - web/**\n - doc/**\n pull_request:\n branches:\n - main\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\njobs:\n build-and-check:\n strategy:\n matrix:\n os: [ubuntu-latest, macos-latest]\n runs-on: ${{ matrix.os }}\n steps:\n - uses: actions/checkout@v5\n - uses: nixbuild/nix-quick-install-action@v34\n - name: Restore and cache Nix store\n uses: nix-community/cache-nix-action@v6\n with:\n primary-key: nix-${{ runner.os }}-${{ hashFiles('**/*.nix') }}\n restore-prefixes-first-match: nix-${{ runner.os }}-\n gc-max-store-size: 1073741824\n purge: true\n purge-prefixes: cache-${{ runner.os }}-\n purge-created: 0\n purge-primary-key: never\n - run: nix build\n - run: nix flake check\n" }, { "path": ".github/workflows/publish-appimage.yml", "content": "name: Build AppImage\non:\n push:\n branches:\n - main\n tags:\n - v*\n paths-ignore:\n - web/**\n - doc/**\n pull_request:\n branches:\n - main\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\nenv:\n SCCACHE_VERSION: '0.9.1'\n\njobs:\n build:\n runs-on: ${{ matrix.os }}\n strategy:\n fail-fast: false\n matrix:\n os:\n - ubuntu-22.04\n - ubuntu-24.04\n arch:\n - x86_64\n mode:\n - debug\n - release\n permissions:\n contents: write\n discussions: write\n steps:\n - run: sudo apt-get -qq update\n - name: Install dependencies\n run: |\n sudo apt-get install -yqq --no-install-recommends \\\n audacious-dev \\\n cmake \\\n gawk \\\n gperf \\\n lcov \\\n libaudclient-dev \\\n libcairo2-dev \\\n libcurl4-gnutls-dev \\\n libdbus-glib-1-dev \\\n libfreetype-dev \\\n libfreetype6-dev \\\n libstdc++6 \\\n libfuse2 \\\n libglib2.0-dev \\\n libical-dev \\\n libimlib2-dev \\\n libircclient-dev \\\n libiw-dev \\\n liblua5.3-dev \\\n libmicrohttpd-dev \\\n libmysqlclient-dev \\\n libpulse-dev \\\n librsvg2-dev \\\n libsystemd-dev \\\n libwayland-bin \\\n libwayland-dev \\\n libx11-dev \\\n libxdamage-dev \\\n libxext-dev \\\n libxft-dev \\\n libxinerama-dev \\\n libxml2-dev \\\n libxmmsclient-dev \\\n libxnvctrl-dev \\\n ncurses-dev \\\n ninja-build \\\n pandoc \\\n wayland-protocols\n - name: Checkout\n uses: actions/checkout@v5\n with:\n fetch-depth: 0\n - uses: actions/setup-python@v6\n with:\n python-version: '3.12'\n cache: 'pip' # caching pip dependencies\n cache-dependency-path: 'requirements-dev.txt'\n - run: pip install -r requirements-dev.txt\n - name: Import GPG Deploy Key\n # only run on main branch\n if: github.ref == 'refs/heads/main'\n run: |\n echo \"${{ secrets.GPG_DEPLOY_KEY }}\" > appimage/secret.gpg\n gpg --import appimage/secret.gpg\n - name: Set clang version to 12 for ubuntu-20.04\n if: matrix.os == 'ubuntu-20.04'\n run: |\n echo \"CLANG_VERSION=12\" | tee -a $GITHUB_ENV\n - name: Set clang version to 15 for ubuntu-22.04\n if: matrix.os == 'ubuntu-22.04'\n run: |\n echo \"CLANG_VERSION=15\" | tee -a $GITHUB_ENV\n - name: Set clang version to 18 for ubuntu-24.04\n if: matrix.os == 'ubuntu-24.04'\n run: |\n echo \"CLANG_VERSION=18\" | tee -a $GITHUB_ENV\n - name: Install libc++, set CC and CXX env vars\n run: |\n sudo apt-get install -yqq --no-install-recommends \\\n libc++-${CLANG_VERSION}-dev \\\n libc++abi-${CLANG_VERSION}-dev\n echo \"CC=clang-${CLANG_VERSION}\" | tee -a $GITHUB_ENV\n echo \"CXX=clang++-${CLANG_VERSION}\" | tee -a $GITHUB_ENV\n\n - name: Install sccache\n if: startsWith(github.ref, 'refs/tags/') != true\n run: .github/scripts/setup-sccache.sh\n - name: Load cached compilation artifacts\n if: startsWith(github.ref, 'refs/tags/') != true\n id: compiler-cache\n uses: actions/cache@v4\n with:\n path: '${{ env.SCCACHE_DIR }}'\n key: sccache-${{ matrix.os }}-${{ matrix.arch }}\n restore-keys: |\n sccache-${{ matrix.os }}-${{ matrix.arch }}\n sccache-${{ matrix.os }}\n sccache-\n - name: Build AppImage\n run: ./appimage/build.sh --${{ matrix.mode }}\n env:\n RELEASE: \"${{ startsWith(github.ref, 'refs/tags/') && 'ON' || 'OFF' }}\"\n - name: Show sccache stats\n if: startsWith(github.ref, 'refs/tags/') != true\n run: sccache --show-stats\n - run: ./conky-x86_64.AppImage --version # print version\n - name: Set CONKY_VERSION\n run: echo \"CONKY_VERSION=$(./conky-x86_64.AppImage --short-version)\" | tee -a $GITHUB_ENV\n - run: mv conky-x86_64.AppImage conky-${{ matrix.os }}-${{ matrix.arch }}-v${{ env.CONKY_VERSION }}-${{ matrix.mode }}.AppImage\n - run: mv conky-x86_64.AppImage.sha256 conky-${{ matrix.os }}-${{ matrix.arch }}-v${{ env.CONKY_VERSION }}-${{ matrix.mode }}.AppImage.sha256\n - name: Upload AppImage artifact\n uses: actions/upload-artifact@v4\n with:\n path: 'conky-${{ matrix.os }}-${{ matrix.arch }}-v${{ env.CONKY_VERSION }}-${{ matrix.mode }}.AppImage'\n name: 'conky-${{ matrix.os }}-${{ matrix.arch }}-v${{ env.CONKY_VERSION }}-${{ matrix.mode }}.AppImage'\n if-no-files-found: error\n - name: Upload AppImage checksum artifact\n uses: actions/upload-artifact@v4\n with:\n path: 'conky-${{ matrix.os }}-${{ matrix.arch }}-v${{ env.CONKY_VERSION }}-${{ matrix.mode }}.AppImage.sha256'\n name: 'conky-${{ matrix.os }}-${{ matrix.arch }}-v${{ env.CONKY_VERSION }}-${{ matrix.mode }}.AppImage.sha256'\n if-no-files-found: error\n - name: Upload man page artifact\n uses: actions/upload-artifact@v4\n with:\n name: conky.1.gz\n path: conky.1.gz\n # conky.1.gz is created by all jobs!\n overwrite: true\n\n release:\n runs-on: ubuntu-latest\n needs: build\n steps:\n - name: Download all artifacts\n uses: actions/download-artifact@v5\n with:\n path: ${{ github.workspace }}/artifacts\n\n - name: Create Conky Release\n id: create_release\n uses: softprops/action-gh-release@v2\n if: startsWith(github.ref, 'refs/tags/')\n with:\n draft: false\n prerelease: false\n discussion_category_name: General\n generate_release_notes: true\n fail_on_unmatched_files: true\n files: |\n ${{ github.workspace }}/artifacts/**/*\n" }, { "path": ".github/workflows/stale.yml", "content": "name: \"Close stale issues and PRs\"\non:\n schedule:\n - cron: \"30 1 * * *\"\n\njobs:\n stale:\n permissions:\n contents: write # for delete-branch option\n issues: write\n pull-requests: write\n runs-on: ubuntu-latest\n steps:\n - uses: actions/stale@v10\n with:\n stale-issue-message: \"This issue is stale because it has been open 365 days with no activity. Remove stale label or comment, or this issue will be closed in 30 days.\"\n stale-pr-message: \"This PR is stale because it has been open 365 days with no activity. Remove stale label or comment, or this PR will be closed in 30 days.\"\n close-issue-message: \"This issue was closed because it has been stalled for 30 days with no activity.\"\n close-pr-message: \"This PR was closed because it has been stalled for 30 days with no activity.\"\n days-before-issue-stale: 365\n days-before-pr-stale: 365\n days-before-issue-close: 30\n days-before-pr-close: 30\n delete-branch: true\n" }, { "path": ".github/workflows/web.yml", "content": "name: Web CI\n\non:\n push:\n branches: [main]\n paths:\n - web/**\n - doc/**\n pull_request:\n branches: [main]\n paths:\n - web/**\n - doc/**\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\njobs:\n build:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v5\n - name: Use Node.js runtime for Next.js\n uses: actions/setup-node@v5\n with:\n node-version: 20\n - name: Use Bun package manager\n uses: oven-sh/setup-bun@v2\n with:\n bun-version: 1.3.10\n - run: bun install --frozen-lockfile\n working-directory: web\n - run: bun run lint\n working-directory: web\n - run: bun run build\n working-directory: web\n - run: bun run e2e:headless\n working-directory: web\n" }, { "path": ".gitignore", "content": ".DS_Store\n*~\n.*.swp\nDoxyfile\npatches/\ndoc/conky.1\nREADME\nbuild*/\ndoc/*.html\n\nMakefile\nCMakeCache.txt\nCMakeFiles\ncmake_install.cmake\ncmake_uninstall.cmake\nCPackConfig.cmake\nCPackSourceConfig.cmake\n\n# Generated files\ndata/convertconf.h\ndata/defconfig.h\n*.so\n*.a\n/config.h\n/build.h\nsrc/colour-names.hh\n\n# Compiler cache\n.cache\n\n# Ignore (most) vscode stuff\n.vscode/*\n*.code-workspace\n# Allow vscode recommended extensions\n!.vscode/extensions.json\n.idea/\n\n# Ignore nix stuff\n/result\n\n# Ignore direnv\n.direnv\n\n# Built AppImages\n/conky*.AppImage\n/conky*.AppImage.sha256\n\n# Built manual\n/conky.1.gz\n" }, { "path": ".prettierrc.cjs", "content": "module.exports = {\n printWidth: 80,\n semi: false,\n singleQuote: true,\n tabWidth: 2,\n useTabs: false,\n}\n" }, { "path": ".vscode/extensions.json", "content": "{\n \"recommendations\": [\n \"kamadorueda.alejandra\",\n \"ms-vscode.cmake-tools\",\n \"mkhl.direnv\",\n \"xaver.clang-format\"\n ]\n}\n" }, { "path": "3rdparty/CMakeLists.txt", "content": "# Vc version 1.4.4\nadd_subdirectory(Vc)\n\nadd_subdirectory(toluapp)\n" }, { "path": "3rdparty/Vc/.clang-format", "content": "BasedOnStyle: Google\n\n# The extra indent or outdent of access modifiers, e.g. public:.\nAccessModifierOffset: -4\n\n# If true, aligns escaped newlines as far left as possible. Otherwise puts them into the right-most column.\nAlignEscapedNewlinesLeft: false\n\n# If true, aligns trailing comments.\nAlignTrailingComments: true\n\n# Allow putting all parameters of a function declaration onto the next line even if BinPackParameters is false.\nAllowAllParametersOfDeclarationOnNextLine: false\n\n# If true, if (a) return; can be put on a single line.\nAllowShortIfStatementsOnASingleLine: false\n\n# If true, while (true) continue; can be put on a single line.\nAllowShortLoopsOnASingleLine: false\n\nAllowShortFunctionsOnASingleLine: true\n\n# If true, always break before multiline string literals.\nAlwaysBreakBeforeMultilineStrings: false\n\n# If true, always break after the template<...> of a template declaration.\nAlwaysBreakTemplateDeclarations: false\n\n# If false, a function call’s or function definition’s parameters will either all be on the same line or will have one line each.\nBinPackParameters: true\n\n# If true, binary operators will be placed after line breaks.\nBreakBeforeBinaryOperators: false\n\n# The brace breaking style to use.\n# Possible values:\n# BS_Attach (in configuration: Attach) Always attach braces to surrounding context.\n# BS_Linux (in configuration: Linux) Like Attach, but break before braces on function, namespace and class definitions.\n# BS_Stroustrup (in configuration: Stroustrup) Like Attach, but break before function definitions.\n# BS_Allman (in configuration: Allman) Always break before braces.\nBreakBeforeBraces: Linux\n\n# Always break constructor initializers before commas and align the commas with the colon.\nBreakConstructorInitializersBeforeComma: true\n\n# The column limit.\n# A column limit of 0 means that there is no column limit. In this case, clang-format will respect the input’s line breaking decisions within statements.\nColumnLimit: 90\n\n# If the constructor initializers don’t fit on a line, put each initializer on its own line.\n#ConstructorInitializerAllOnOneLineOrOnePerLine (bool)\n\n# The number of characters to use for indentation of constructor initializer lists.\n#ConstructorInitializerIndentWidth (unsigned)\n\n# If true, format braced lists as best suited for C++11 braced lists.\n# Important differences: - No spaces inside the braced list. - No line break before the closing brace. - Indentation with the continuation indent, not with the block indent.\n# Fundamentally, C++11 braced lists are formatted exactly like function calls would be formatted in their place. If the braced list follows a name (e.g. a type or variable name), clang-format formats as if the {} were the parentheses of a function call with that name. If there is no name, a zero-length name is assumed.\nCpp11BracedListStyle: true\n\n# If true, analyze the formatted file for the most common binding.\n#DerivePointerBinding (bool)\n\n# If true, clang-format detects whether function calls and definitions are formatted with one parameter per line.\n# Each call can be bin-packed, one-per-line or inconclusive. If it is inconclusive, e.g. completely on one line, but a decision needs to be made, clang-format analyzes whether there are other bin-packed cases in the input file and act accordingly.\n# NOTE: This is an experimental flag, that might go away or be renamed. Do not use this in config files, etc. Use at your own risk.\n#ExperimentalAutoDetectBinPacking (bool)\n\n# Indent case labels one level from the switch statement.\n# When false, use the same indentation level as for the switch statement. Switch statement body is always indented one level more than case labels.\nIndentCaseLabels: false\n\n# If true, indent when breaking function declarations which are not also definitions after the type.\n#IndentFunctionDeclarationAfterType (bool)\n\n# The number of characters to use for indentation.\nIndentWidth: 4\n\n# The maximum number of consecutive empty lines to keep.\nMaxEmptyLinesToKeep: 1\n\n# The indentation used for namespaces.\n# Possible values:\n# NI_None (in configuration: None) Don’t indent in namespaces.\n# NI_Inner (in configuration: Inner) Indent only in inner namespaces (nested in other namespaces).\n# NI_All (in configuration: All) Indent in all namespaces.\nNamespaceIndentation: None\n\n# Add a space in front of an Objective-C protocol list, i.e. use Foo instead of Foo.\n#ObjCSpaceBeforeProtocolList (bool)\n\n# The penalty for each line break introduced inside a comment.\n#PenaltyBreakComment (unsigned)\n\n# The penalty for breaking before the first <<.\n#PenaltyBreakFirstLessLess (unsigned)\n\n# The penalty for each line break introduced inside a string literal.\n#PenaltyBreakString (unsigned)\n# The penalty for each character outside of the column limit.\n#PenaltyExcessCharacter (unsigned)\n# Penalty for putting the return type of a function onto its own line.\n#PenaltyReturnTypeOnItsOwnLine (unsigned)\n# Set whether & and * bind to the type as opposed to the variable.\n#PointerBindsToType: false\n# If true, spaces will be inserted between ‘for’/’if’/’while’/... and ‘(‘.\n#SpaceAfterControlStatementKeyword: true\n# If false, spaces will be removed before ‘=’, ‘+=’, etc.\n#SpaceBeforeAssignmentOperators: true\n# If false, spaces may be inserted into ‘()’.\n#SpaceInEmptyParentheses: false\n# The number of spaces to before trailing line comments.\n#SpacesBeforeTrailingComments (unsigned)\n# If false, spaces may be inserted into C style casts.\n#SpacesInCStyleCastParentheses (bool)\n\n# If true, spaces will be inserted after every ‘(‘ and before every ‘)’.\nSpacesInParentheses: false\n\n# Format compatible with this standard, e.g. use A > instead of A> for LS_Cpp03.\n# Possible values:\n# LS_Cpp03 (in configuration: Cpp03) Use C++03-compatible syntax.\n# LS_Cpp11 (in configuration: Cpp11) Use features of C++11 (e.g. A> instead of A >).\n# LS_Auto (in configuration: Auto) Automatic detection based on the input.\nStandard: Cpp11\n\n# If true, IndentWidth consecutive spaces will be replaced with tab characters.\nUseTab: false\n\n# vim: ft=yaml\n" }, { "path": "3rdparty/Vc/.gitignore", "content": "doc/html\ndoc/latex\ndoc/man\nvc-benchmarks\n*.swp\n*~\n.makeApidox.stamp\n.makeApidox.stamp.new\nbuild-*\n.vs\nout\n" }, { "path": "3rdparty/Vc/CMakeLists.txt", "content": "# cmake_minimum_required(VERSION 3.0)\n\ncmake_policy(SET CMP0028 NEW) # Double colon in target name means ALIAS or IMPORTED target.\ncmake_policy(SET CMP0048 NEW) # The ``project()`` command manages VERSION variables.\n\nif(PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR)\n message(FATAL_ERROR \"You don't want to configure in the source directory!\")\nendif()\n\nif(NOT DEFINED CMAKE_BUILD_TYPE)\n set(CMAKE_BUILD_TYPE Release CACHE STRING\n \"Choose the type of build, options are: None Debug Release RelWithDebug RelWithDebInfo MinSizeRel.\"\n FORCE)\nendif()\n\n# read version parts from version.h\nfile(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/Vc/version.h _version_lines REGEX \"^#define Vc_VERSION_STRING \")\nstring(REGEX MATCH \"([0-9]+)\\\\.([0-9]+)\\\\.([0-9]+)\" _version_matches \"${_version_lines}\")\n\nproject(Vc VERSION \"${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}\" LANGUAGES C CXX)\nlist(APPEND CMAKE_MODULE_PATH \"${CMAKE_CURRENT_LIST_DIR}/cmake\")\n\nset(CMAKE_CXX_STANDARD 14)\nset(CMAKE_CXX_STANDARD_REQUIRED ON)\n\nset(disabled_targets)\n\ninclude (VcMacros)\ninclude (AddTargetProperty)\ninclude (OptimizeForArchitecture)\n\nvc_determine_compiler()\n\nif(\"${CMAKE_SYSTEM_PROCESSOR}\" MATCHES \"(i686|x86|AMD64|amd64)\")\n set(Vc_X86 TRUE)\nelseif(\"${CMAKE_SYSTEM_PROCESSOR}\" MATCHES \"(arm|aarch32|aarch64)\")\n message(WARNING \"No optimized implementation of the Vc types available for ${CMAKE_SYSTEM_PROCESSOR}\")\n set(Vc_ARM TRUE)\nelse()\n message(WARNING \"No optimized implementation of the Vc types available for ${CMAKE_SYSTEM_PROCESSOR}\")\nendif()\n\n# if(NOT Vc_COMPILER_IS_MSVC)\n# AddCompilerFlag(\"-std=c++14\" CXX_RESULT _ok CXX_FLAGS CMAKE_CXX_FLAGS)\n# if(NOT _ok)\n# AddCompilerFlag(\"-std=c++1y\" CXX_RESULT _ok CXX_FLAGS CMAKE_CXX_FLAGS)\n# if(NOT _ok)\n# AddCompilerFlag(\"-std=c++11\" CXX_RESULT _ok CXX_FLAGS CMAKE_CXX_FLAGS)\n# if(NOT _ok)\n# AddCompilerFlag(\"-std=c++0x\" CXX_RESULT _ok CXX_FLAGS CMAKE_CXX_FLAGS)\n# if(NOT _ok)\n# message(FATAL_ERROR \"Vc 1.x requires C++11, better even C++14. It seems this is not available. If this was incorrectly determined please notify vc-devel@compeng.uni-frankfurt.de\")\n# endif()\n# endif()\n# endif()\n# endif()\n# elseif(MSVC_VERSION LESS 1920)\n# message(FATAL_ERROR \"Vc 1.x requires at least Visual Studio 2019.\")\n# AddCompilerFlag(\"/std:c++14\" CXX_RESULT _ok CXX_FLAGS CMAKE_CXX_FLAGS)\n# endif()\n\n# if(MSVC AND (NOT DEFINED Vc_USE_MSVC_SSA_OPTIMIZER_DESPITE_BUGGY_EXP OR NOT Vc_USE_MSVC_SSA_OPTIMIZER_DESPITE_BUGGY_EXP))\n# # bug report: https://developercommunity.visualstudio.com/t/AVX-codegen-bug-on-Vc-with-MSVC-2019/1470844#T-N1521672\n# message(STATUS \"WARNING! MSVC starting with 19.20 uses a new optimizer that has a bug causing Vc::exp() to return slighly wrong results.\\\n# You can set Vc_USE_MSVC_SSA_OPTIMIZER_DESPITE_BUGGY_EXP=ON to still use the new optimizer on the affected MSVC versions.\")\n# AddCompilerFlag(\"/d2SSAOptimizer-\" CXX_RESULT _ok CXX_FLAGS CMAKE_CXX_FLAGS)\n# endif()\n\nif(Vc_COMPILER_IS_GCC)\n if(Vc_GCC_VERSION VERSION_GREATER \"5.0.0\" AND Vc_GCC_VERSION VERSION_LESS \"6.0.0\")\n UserWarning(\"GCC 5 goes into an endless loop comiling example_scaling_scalar. Therefore, this target is disabled.\")\n list(APPEND disabled_targets\n example_scaling_scalar\n )\n endif()\n# elseif(Vc_COMPILER_IS_MSVC)\n# # Disable warning \"C++ exception specification ignored except to indicate a function is not __declspec(nothrow)\"\n# # MSVC emits the warning for the _UnitTest_Compare desctructor which needs the throw declaration so that it doesn't std::terminate\n# AddCompilerFlag(\"/wd4290\")\nendif()\n\nvc_set_preferred_compiler_flags(WARNING_FLAGS BUILDTYPE_FLAGS)\n\nadd_definitions(${Vc_DEFINITIONS})\nadd_compile_options(${Vc_COMPILE_FLAGS})\n\nif(Vc_COMPILER_IS_INTEL)\n # per default icc is not IEEE compliant, but we need that for verification\n AddCompilerFlag(\"-fp-model source\")\nendif()\n\nif(CMAKE_BUILD_TYPE STREQUAL \"\" AND NOT CMAKE_CXX_FLAGS MATCHES \"-O[123]\")\n message(STATUS \"WARNING! It seems you are compiling without optimization. Please set CMAKE_BUILD_TYPE.\")\nendif(CMAKE_BUILD_TYPE STREQUAL \"\" AND NOT CMAKE_CXX_FLAGS MATCHES \"-O[123]\")\n\ninclude_directories(${CMAKE_CURRENT_SOURCE_DIR}) # ${CMAKE_CURRENT_SOURCE_DIR}/include)\n\nadd_custom_target(other VERBATIM)\nadd_custom_target(Scalar COMMENT \"build Scalar code\" VERBATIM)\nadd_custom_target(SSE COMMENT \"build SSE code\" VERBATIM)\nadd_custom_target(AVX COMMENT \"build AVX code\" VERBATIM)\nadd_custom_target(AVX2 COMMENT \"build AVX2 code\" VERBATIM)\n\nAddCompilerFlag(-ftemplate-depth=128 CXX_FLAGS CMAKE_CXX_FLAGS)\n\nset(libvc_compile_flags \"-DVc_COMPILE_LIB\")\nAddCompilerFlag(\"-fPIC\" CXX_FLAGS libvc_compile_flags)\n\n# -fstack-protector is the default of GCC, but at least Ubuntu changes the default to -fstack-protector-strong, which is crazy\nAddCompilerFlag(\"-fstack-protector\" CXX_FLAGS libvc_compile_flags)\n\nset(_srcs src/const.cpp)\nif(Vc_X86)\n list(APPEND _srcs src/cpuid.cpp src/support_x86.cpp)\n vc_compile_for_all_implementations(_srcs src/trigonometric.cpp ONLY SSE2 SSE3 SSSE3 SSE4_1 AVX AVX+FMA AVX2+FMA+BMI2)\n if(NOT Vc_XOP_INTRINSICS_BROKEN)\n vc_compile_for_all_implementations(_srcs src/trigonometric.cpp ONLY AVX+XOP+FMA)\n if(NOT Vc_FMA4_INTRINSICS_BROKEN)\n vc_compile_for_all_implementations(_srcs src/trigonometric.cpp ONLY SSE+XOP+FMA4 AVX+XOP+FMA4)\n endif()\n endif()\n vc_compile_for_all_implementations(_srcs src/sse_sorthelper.cpp ONLY SSE2 SSE4_1 AVX AVX2+FMA+BMI2)\n vc_compile_for_all_implementations(_srcs src/avx_sorthelper.cpp ONLY AVX AVX2+FMA+BMI2)\nelseif(Vc_ARM)\n list(APPEND _srcs src/support_dummy.cpp)\nelse()\n list(APPEND _srcs src/support_dummy.cpp)\nendif()\nadd_library(Vc STATIC ${_srcs})\nset_property(TARGET Vc APPEND PROPERTY COMPILE_OPTIONS ${libvc_compile_flags})\nadd_target_property(Vc LABELS \"other\")\nif(XCODE)\n # TODO: document what this does and why it has no counterpart in the non-XCODE logic\n set_target_properties(Vc PROPERTIES XCODE_ATTRIBUTE_GCC_INLINES_ARE_PRIVATE_EXTERN \"NO\")\n set_target_properties(Vc PROPERTIES XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN \"YES\")\n set_target_properties(Vc PROPERTIES XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD \"c++0x\")\n set_target_properties(Vc PROPERTIES XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY \"libc++\")\nelseif(UNIX AND Vc_COMPILER_IS_CLANG)\n # On UNIX (Linux) the standard library used by default typically is libstdc++ (GCC).\n # To get the full clang deal we rather want to build against libc++. This requires\n # additionally the libc++abi and libsupc++ libraries in all linker invokations.\n option(USE_LIBC++ \"Use libc++ instead of the system default C++ standard library.\" OFF)\n if(USE_LIBC++)\n AddCompilerFlag(-stdlib=libc++ CXX_FLAGS CMAKE_CXX_FLAGS CXX_RESULT _use_libcxx)\n if(_use_libcxx)\n find_library(LIBC++ABI c++abi)\n mark_as_advanced(LIBC++ABI)\n if(LIBC++ABI)\n set(CMAKE_REQUIRED_LIBRARIES \"${LIBC++ABI};supc++\")\n CHECK_CXX_SOURCE_COMPILES(\"#include \n #include \n void foo() {\n std::cout << 'h' << std::flush << std::endl;\n throw std::exception();\n }\n int main() {\n try { foo(); }\n catch (int) { return 0; }\n return 1;\n }\" libcxx_compiles)\n unset(CMAKE_REQUIRED_LIBRARIES)\n if(libcxx_compiles)\n link_libraries(${LIBC++ABI} supc++)\n endif()\n endif()\n endif()\n else()\n CHECK_CXX_SOURCE_COMPILES(\"#include \n std::tuple f() { std::tuple r; return r; }\n int main() { return 0; }\n \" tuple_sanity)\n if (NOT tuple_sanity)\n message(FATAL_ERROR \"Clang and std::tuple brokenness detected. Please update your compiler.\")\n endif()\n endif()\nendif()\nadd_dependencies(other Vc)\ntarget_include_directories(Vc\n PUBLIC\n $\n $\n )\n\n# option(Vc_ENABLE_INSTALL \"Whether to install the library.\" OFF)\n# if (Vc_ENABLE_INSTALL)\n# install(TARGETS Vc EXPORT VcTargets DESTINATION lib${LIB_SUFFIX})\n# install(DIRECTORY Vc/ DESTINATION include/Vc FILES_MATCHING REGEX \"/*.(h|tcc|def)$\")\n# install(FILES\n# Vc/Allocator\n# Vc/IO\n# Vc/Memory\n# Vc/SimdArray\n# Vc/Utils\n# Vc/Vc\n# Vc/algorithm\n# Vc/array\n# Vc/iterators\n# Vc/limits\n# Vc/simdize\n# Vc/span\n# Vc/type_traits\n# Vc/vector\n# DESTINATION include/Vc)\n\n# # Generate and install CMake package and modules\n# include(CMakePackageConfigHelpers)\n# set(PACKAGE_INSTALL_DESTINATION\n# lib${LIB_SUFFIX}/cmake/${PROJECT_NAME}\n# )\n# install(EXPORT ${PROJECT_NAME}Targets\n# NAMESPACE ${PROJECT_NAME}::\n# DESTINATION ${PACKAGE_INSTALL_DESTINATION}\n# EXPORT_LINK_INTERFACE_LIBRARIES\n# )\n# write_basic_package_version_file(\n# ${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake\n# VERSION ${PROJECT_VERSION}\n# COMPATIBILITY AnyNewerVersion\n# )\n# configure_package_config_file(\n# ${PROJECT_SOURCE_DIR}/cmake/${PROJECT_NAME}Config.cmake.in\n# ${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake\n# INSTALL_DESTINATION ${PACKAGE_INSTALL_DESTINATION}\n# PATH_VARS CMAKE_INSTALL_PREFIX\n# )\n# install(FILES\n# cmake/UserWarning.cmake\n# cmake/VcMacros.cmake\n# cmake/AddCompilerFlag.cmake\n# cmake/CheckCCompilerFlag.cmake\n# cmake/CheckCXXCompilerFlag.cmake\n# cmake/OptimizeForArchitecture.cmake\n# cmake/FindVc.cmake\n# ${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake\n# ${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake\n# DESTINATION ${PACKAGE_INSTALL_DESTINATION}\n# )\n# endif()\n\n# option(BUILD_TESTING \"Build the testing tree.\" OFF)\n# include (CTest)\n# configure_file(${PROJECT_SOURCE_DIR}/CTestCustom.cmake ${PROJECT_BINARY_DIR}/CTestCustom.cmake COPYONLY)\n# if(BUILD_TESTING)\n # add_custom_target(build_tests ALL VERBATIM)\n # add_subdirectory(tests)\n# endif()\n\n# set(BUILD_EXAMPLES FALSE CACHE BOOL \"Build examples.\")\n# if(BUILD_EXAMPLES)\n # add_subdirectory(examples)\n# endif(BUILD_EXAMPLES)\n\n# Hide Vc_IMPL as it is only meant for users of Vc\nmark_as_advanced(Vc_IMPL)\n\n# find_program(BIN_CAT cat)\n# mark_as_advanced(BIN_CAT)\n# if(BIN_CAT)\n# file(REMOVE ${PROJECT_BINARY_DIR}/help.txt)\n# add_custom_command(OUTPUT ${PROJECT_BINARY_DIR}/help.txt\n# COMMAND ${CMAKE_MAKE_PROGRAM} help > ${PROJECT_BINARY_DIR}/help.txt\n# VERBATIM\n# )\n# add_custom_target(cached_help\n# ${BIN_CAT} ${PROJECT_BINARY_DIR}/help.txt\n# DEPENDS ${PROJECT_BINARY_DIR}/help.txt\n# VERBATIM\n# )\n# endif()\n" }, { "path": "3rdparty/Vc/LICENSE", "content": "Copyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "3rdparty/Vc/README.md", "content": "**Vc is now in maintenance mode and no longer actively developed.\nHowever, we continue to review pull requests with bugfixes from the community.**\n\n**You may be interested in switching to [std-simd](https://github.com/VcDevel/std-simd).**\nGCC 11 includes an experimental version of `std::simd` as part of libstdc++, which also works with clang.\nFeatures present in Vc 1.4 and not present in *std-simd* will eventually turn into Vc 2.0,which then depends on *std-simd*.\n\n# Vc: portable, zero-overhead C++ types for explicitly data-parallel programming\n\nRecent generations of CPUs, and GPUs in particular, require data-parallel codes\nfor full efficiency. Data parallelism requires that the same sequence of\noperations is applied to different input data. CPUs and GPUs can thus reduce\nthe necessary hardware for instruction decoding and scheduling in favor of more\narithmetic and logic units, which execute the same instructions synchronously.\nOn CPU architectures this is implemented via SIMD registers and instructions.\nA single SIMD register can store N values and a single SIMD instruction can\nexecute N operations on those values. On GPU architectures N threads run in\nperfect sync, fed by a single instruction decoder/scheduler. Each thread has\nlocal memory and a given index to calculate the offsets in memory for loads and\nstores.\n\nCurrent C++ compilers can do automatic transformation of scalar codes to SIMD\ninstructions (auto-vectorization). However, the compiler must reconstruct an\nintrinsic property of the algorithm that was lost when the developer wrote a\npurely scalar implementation in C++. Consequently, C++ compilers cannot\nvectorize any given code to its most efficient data-parallel variant.\nEspecially larger data-parallel loops, spanning over multiple functions or even\ntranslation units, will often not be transformed into efficient SIMD code.\n\nThe Vc library provides the missing link. Its types enable explicitly stating\ndata-parallel operations on multiple values. The parallelism is therefore added\nvia the type system. Competing approaches state the parallelism via new control\nstructures and consequently new semantics inside the body of these control\nstructures.\n\nVc is a free software library to ease explicit vectorization of C++ code. It\nhas an intuitive API and provides portability between different compilers and\ncompiler versions as well as portability between different vector instruction\nsets. Thus an application written with Vc can be compiled for:\n\n* AVX and AVX2\n* SSE2 up to SSE4.2 or SSE4a\n* Scalar\n* ~~AVX-512 (Vc 2 development)~~\n* ~~NEON (in development)~~\n* ~~NVIDIA GPUs / CUDA (research)~~\n\nAfter Intel dropped MIC support with ICC 18, Vc 1.4 also removed support for it.\n\n## Examples\n\n### Usage on Compiler Explorer\n\n* [Simdize Example](https://godbolt.org/z/JVEM2j)\n* [Total momentum and time stepping of `std::vector`](https://godbolt.org/z/JNdkL9)\n* [Matrix Example](https://godbolt.org/z/fFEkuX): This uses vertical\n vectorization which does not scale to different vector sizes. However, the\n example is instructive to compare it with similar solutions of other languages\n or libraries.\n* [N-vortex solver](https://godbolt.org/z/4o1cg_) showing `simdize`d iteration\n over many `std::vector`. Note how [important the `-march` flag is, compared\n to plain `-mavx2 -mfma`](https://godbolt.org/z/hKiOjr).\n\n### Scalar Product\n\nLet's start from the code for calculating a 3D scalar product using builtin floats:\n```cpp\nusing Vec3D = std::array;\nfloat scalar_product(Vec3D a, Vec3D b) {\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n```\nUsing Vc, we can easily vectorize the code using the `float_v` type:\n```cpp\nusing Vc::float_v\nusing Vec3D = std::array;\nfloat_v scalar_product(Vec3D a, Vec3D b) {\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n```\nThe above will scale to 1, 4, 8, 16, etc. scalar products calculated in parallel, depending\non the target hardware's capabilities.\n\nFor comparison, the same vectorization using Intel SSE intrinsics is more verbose and uses\nprefix notation (i.e. function calls):\n```cpp\nusing Vec3D = std::array<__m128, 3>;\n__m128 scalar_product(Vec3D a, Vec3D b) {\n return _mm_add_ps(_mm_add_ps(_mm_mul_ps(a[0], b[0]), _mm_mul_ps(a[1], b[1])),\n _mm_mul_ps(a[2], b[2]));\n}\n```\nThe above will neither scale to AVX, AVX-512, etc. nor is it portable to other SIMD ISAs.\n\n## Build Requirements\n\ncmake >= 3.0\n\nC++11 Compiler:\n\n* GCC >= 4.8.1\n* clang >= 3.4\n* ICC >= 18.0.5\n* Visual Studio 2019 (64-bit target)\n\n\n## Building and Installing Vc\n\n* Clone Vc and initialize Vc's git submodules:\n\n```sh\ngit clone https://github.com/VcDevel/Vc.git\ncd Vc\ngit submodule update --init\n```\n\n* Create a build directory:\n\n```sh\n$ mkdir build\n$ cd build\n```\n\n* Configure with cmake and add relevant options:\n\n```sh\n$ cmake ..\n```\n\nOptionally, specify an installation directory:\n\n```sh\n$ cmake -DCMAKE_INSTALL_PREFIX=/opt/Vc ..\n```\n\nOptionally, include building the unit tests:\n\n```sh\n$ cmake -DBUILD_TESTING=ON ..\n```\n\nOn Windows, if you have multiple versions of Visual Studio installed, you can select one:\n\n```sh\n$ cmake -G \"Visual Studio 16 2019\" ..\n```\n\nSee `cmake --help` for a list of possible generators.\n\n\n* Build and install:\n\n```sh\n$ cmake --build . -j 16\n$ cmake --install . # may require permissions\n```\n\nOn Windows, you can also open `Vc.sln` in Visual Studio and build/install from the IDE.\n\n## Documentation\n\nThe documentation is generated via [doxygen](http://doxygen.org). You can build\nthe documentation by running `doxygen` in the `doc` subdirectory.\nAlternatively, you can find nightly builds of the documentation at:\n\n* [1.4 branch](https://vcdevel.github.io/Vc-1.4/)\n* [1.4.4 release](https://vcdevel.github.io/Vc-1.4.4/)\n* [1.4.3 release](https://vcdevel.github.io/Vc-1.4.3/)\n* [1.4.2 release](https://vcdevel.github.io/Vc-1.4.2/)\n* [1.4.1 release](https://vcdevel.github.io/Vc-1.4.1/)\n* [1.4.0 release](https://vcdevel.github.io/Vc-1.4.0/)\n* [1.3 branch](https://vcdevel.github.io/Vc-1.3/)\n* [1.3.0 release](https://vcdevel.github.io/Vc-1.3.0/)\n* [1.2.0 release](https://vcdevel.github.io/Vc-1.2.0/)\n* [1.1.0 release](https://vcdevel.github.io/Vc-1.1.0/)\n* [0.7 branch](https://vcdevel.github.io/Vc-0.7/)\n\n## Publications\n\n* [M. Kretz, \"Extending C++ for Explicit Data-Parallel Programming via SIMD\n Vector Types\", Goethe University Frankfurt, Dissertation,\n 2015.](http://publikationen.ub.uni-frankfurt.de/frontdoor/index/index/docId/38415)\n* [M. Kretz and V. Lindenstruth, \"Vc: A C++ library for explicit\n vectorization\", Software: Practice and Experience,\n 2011.](http://dx.doi.org/10.1002/spe.1149)\n* [M. Kretz, \"Efficient Use of Multi- and Many-Core Systems with Vectorization\n and Multithreading\", University of Heidelberg,\n 2009.](http://code.compeng.uni-frankfurt.de/attachments/13/Diplomarbeit.pdf)\n\n[Work on integrating the functionality of Vc in the C++ standard library.](\nhttps://github.com/VcDevel/Vc/wiki/ISO-Standardization-of-the-Vector-classes)\n\n## License\n\nVc is released under the terms of the [3-clause BSD license](http://opensource.org/licenses/BSD-3-Clause).\n" }, { "path": "3rdparty/Vc/Vc/Allocator", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_ALLOCATOR_H_\n#define VC_ALLOCATOR_H_\n\n#include \n#include \n#include \n#include \n\n#include \"global.h\"\n#include \"common/macros.h\"\n\n/**\n * \\ingroup Utilities\n *\n * Convenience macro to set the default allocator for a given \\p Type to\n * Vc::Allocator.\n *\n * \\param Type Your type that you want to use with STL containers.\n *\n * \\note You have to use this macro in the global namespace.\n */\n#ifdef Vc_MSVC\n#define Vc_DECLARE_ALLOCATOR(Type) \\\nnamespace std \\\n{ \\\ntemplate <> class allocator : public ::Vc::Allocator \\\n{ \\\npublic: \\\n template struct rebind { \\\n typedef ::std::allocator other; \\\n }; \\\n /* MSVC brokenness: the following function is optional - just doesn't compile \\\n * without it */ \\\n const allocator &select_on_container_copy_construction() const { return *this; } \\\n}; \\\n}\n#else\n#define Vc_DECLARE_ALLOCATOR(Type) \\\nnamespace std \\\n{ \\\ntemplate <> class allocator : public ::Vc::Allocator \\\n{ \\\npublic: \\\n template struct rebind { \\\n typedef ::std::allocator other; \\\n }; \\\n}; \\\n}\n#endif\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n using std::size_t;\n using std::ptrdiff_t;\n\n /**\n * \\headerfile Allocator \n * An allocator that uses global new and supports over-aligned types, as per [C++11 20.6.9].\n *\n * Meant as a simple replacement for the allocator defined in the C++ Standard.\n * Allocation is done using the global new/delete operators. But if the alignment property of \\p\n * T is larger than the size of a pointer, the allocate function allocates slightly more memory\n * to adjust the pointer for correct alignment.\n *\n * If the \\p T does not require over-alignment no additional memory will be allocated.\n *\n * \\tparam T The type of objects to allocate.\n *\n * Example:\n * \\code\n * struct Data {\n * Vc::float_v x, y, z;\n * };\n *\n * void fun()\n * {\n * std::vector dat0; // this will use std::allocator, which probably ignores the\n * // alignment requirements for Data. Thus any access to dat0 may\n * // crash your program.\n *\n * std::vector > dat1; // now std::vector will get correctly aligned\n * // memory. Accesses to dat1 are safe.\n * ...\n * \\endcode\n *\n * %Vc ships a macro to conveniently tell STL to use Vc::Allocator per default for a given type:\n * \\code\n * struct Data {\n * Vc::float_v x, y, z;\n * };\n * Vc_DECLARE_ALLOCATOR(Data)\n *\n * void fun()\n * {\n * std::vector dat0; // good now\n * ...\n * \\endcode\n *\n * \\ingroup Utilities\n */\n template class Allocator\n {\n private:\n enum Constants {\n#ifdef Vc_HAVE_STD_MAX_ALIGN_T\n NaturalAlignment = alignof(std::max_align_t),\n#elif defined(Vc_HAVE_MAX_ALIGN_T)\n NaturalAlignment = alignof(::max_align_t),\n#else\n NaturalAlignment = sizeof(void *) > alignof(long double) ? sizeof(void *) :\n (alignof(long double) > alignof(long long) ? alignof(long double) : alignof(long long)),\n#endif\n#if defined Vc_IMPL_AVX\n SimdAlignment = 32,\n#elif defined Vc_IMPL_SSE\n SimdAlignment = 16,\n#else\n SimdAlignment = 1,\n#endif\n Alignment = alignof(T) > SimdAlignment ? alignof(T) : SimdAlignment,\n /* The number of extra bytes allocated must be large enough to put a pointer right\n * before the adjusted address. This pointer stores the original address, which is\n * required to call ::operator delete in deallocate.\n *\n * The address we get from ::operator new is a multiple of NaturalAlignment:\n * p = N * NaturalAlignment\n *\n * Since all alignments are powers of two, Alignment is a multiple of NaturalAlignment:\n * Alignment = k * NaturalAlignment\n *\n * two cases:\n * 1. If p is already aligned to Alignment then allocate will return p + Alignment. In\n * this case there are Alignment Bytes available to store a pointer.\n * 2. If p is not aligned then p + (k - (N modulo k)) * NaturalAlignment will be\n * returned. Since NaturalAlignment >= sizeof(void*) the pointer fits.\n */\n ExtraBytes = Alignment > NaturalAlignment ? Alignment : 0,\n AlignmentMask = Alignment - 1\n };\n public:\n typedef size_t size_type;\n typedef ptrdiff_t difference_type;\n typedef T* pointer;\n typedef const T* const_pointer;\n typedef T& reference;\n typedef const T& const_reference;\n typedef T value_type;\n\n template struct rebind { typedef Allocator other; };\n\n Allocator() throw() { }\n Allocator(const Allocator&) throw() { }\n template Allocator(const Allocator&) throw() { }\n\n pointer address(reference x) const { return &x; }\n const_pointer address(const_reference x) const { return &x; }\n\n pointer allocate(size_type n, const void* = 0)\n {\n if (n > this->max_size()) {\n throw std::bad_alloc();\n }\n\n char *p = static_cast(::operator new(n * sizeof(T) + ExtraBytes));\n if (ExtraBytes > 0) {\n char *const pp = p;\n p += ExtraBytes;\n const char *null = 0;\n p -= ((p - null) & AlignmentMask); // equivalent to p &= ~AlignmentMask;\n reinterpret_cast(p)[-1] = pp;\n }\n return reinterpret_cast(p);\n }\n\n void deallocate(pointer p, size_type)\n {\n if (ExtraBytes > 0) {\n p = reinterpret_cast(p)[-1];\n }\n ::operator delete(p);\n }\n\n size_type max_size() const throw() { return size_t(-1) / sizeof(T); }\n\n#ifdef Vc_MSVC\n // MSVC brokenness: the following function is optional - just doesn't compile without it\n const Allocator &select_on_container_copy_construction() const { return *this; }\n\n // MSVC also requires a function that neither C++98 nor C++11 mention\n // but it doesn't support variadic templates... otherwise the Vc_CXX11 clause would be nice\n void construct(pointer p) { ::new(p) T(); }\n\n // we still need the C++98 version:\n void construct(pointer p, const T& val) { ::new(p) T(val); }\n void destroy(pointer p) { p->~T(); }\n#else\n template void construct(U* p, Args&&... args)\n {\n ::new(p) U(std::forward(args)...);\n }\n template void destroy(U* p) { p->~U(); }\n#endif\n };\n\n template inline bool operator==(const Allocator&, const Allocator&) { return true; }\n template inline bool operator!=(const Allocator&, const Allocator&) { return false; }\n\n}\n\n#include \"vector.h\"\nnamespace std\n{\n template\n class allocator > : public ::Vc::Allocator >\n {\n public:\n template struct rebind { typedef ::std::allocator other; };\n#ifdef Vc_MSVC\n // MSVC brokenness: the following function is optional - just doesn't compile without it\n const allocator &select_on_container_copy_construction() const { return *this; }\n#endif\n };\n template \n class allocator> : public ::Vc::Allocator>\n {\n public:\n template struct rebind { typedef ::std::allocator other; };\n#ifdef Vc_MSVC\n // MSVC brokenness: the following function is optional - just doesn't compile without it\n const allocator &select_on_container_copy_construction() const { return *this; }\n#endif\n };\n template \n class allocator> : public ::Vc::Allocator>\n {\n public:\n template struct rebind { typedef ::std::allocator other; };\n#ifdef Vc_MSVC\n // MSVC brokenness: the following function is optional - just doesn't compile without it\n const allocator &select_on_container_copy_construction() const { return *this; }\n#endif\n };\n template \n class allocator> : public ::Vc::Allocator>\n {\n public:\n template struct rebind { typedef ::std::allocator other; };\n#ifdef Vc_MSVC\n // MSVC brokenness: the following function is optional - just doesn't compile without it\n const allocator &select_on_container_copy_construction() const { return *this; }\n#endif\n };\n}\n\n#endif // VC_ALLOCATOR_H_\n\n// vim: ft=cpp et sw=4 sts=4\n" }, { "path": "3rdparty/Vc/Vc/IO", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_IO_\n#define VC_IO_\n\n#include \"common/types.h\"\n#include \"common/simdarrayfwd.h\"\n#include \"common/memoryfwd.h\"\n#include \n\n#if defined(__GNUC__) && !defined(_WIN32) && defined(_GLIBCXX_OSTREAM)\n#define Vc_HACK_OSTREAM_FOR_TTY 1\n#endif\n\n#ifdef Vc_HACK_OSTREAM_FOR_TTY\n#include \n#include \n#endif\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace\n{\n#ifdef Vc_HACK_OSTREAM_FOR_TTY\nclass hacked_ostream : public std::ostream\n{\npublic:\n using std::ostream::_M_streambuf;\n};\nbool mayUseColor(const std::ostream &os) __attribute__((__const__));\nbool mayUseColor(const std::ostream &os)\n{\n std::basic_streambuf *hack1 =\n const_cast *>(os.*(&hacked_ostream::_M_streambuf));\n __gnu_cxx::stdio_sync_filebuf *hack =\n dynamic_cast<__gnu_cxx::stdio_sync_filebuf *>(hack1);\n if (!hack) {\n return false;\n }\n FILE *file = hack->file();\n return 1 == isatty(fileno(file));\n}\n#else\nbool mayUseColor(const std::ostream &) { return false; }\n#endif\n} // anonymous namespace\n\nnamespace AnsiColor\n{\nstruct Type\n{\n const char *data;\n};\nstatic const Type green = {\"\\033[1;40;32m\"};\nstatic const Type yellow = {\"\\033[1;40;33m\"};\nstatic const Type blue = {\"\\033[1;40;34m\"};\nstatic const Type normal = {\"\\033[0m\"};\n\ninline std::ostream &operator<<(std::ostream &out, const Type &c)\n{\n if (mayUseColor(out)) {\n out << c.data;\n }\n return out;\n}\n} // namespace AnsiColor\n\n/**\n * \\ingroup Vectors\n * \\headerfile IO \n *\n * Prints the contents of a vector into a stream object.\n *\n * \\code\n * const Vc::int_v v(Vc::IndexesFromZero);\n * std::cout << v << std::endl;\n * \\endcode\n * will output (with SSE):\n\\verbatim\n[0, 1, 2, 3]\n\\endverbatim\n *\n * \\param out Any standard C++ ostream object. For example std::cout or a\n * std::stringstream object.\n * \\param v Any Vc::Vector object.\n * \\return The ostream object: to chain multiple stream operations.\n *\n * \\note With the GNU standard library this function will check whether the\n * output stream is a tty in which case it colorizes the output.\n */\ntemplate \ninline std::ostream &operator<<(std::ostream &out, const Vc::Vector &v)\n{\n using TT = typename std::conditional::value ||\n std::is_same::value ||\n std::is_same::value,\n int,\n T>::type;\n out << AnsiColor::green << '[';\n out << TT(v[0]);\n for (size_t i = 1; i < v.Size; ++i) {\n out << \", \" << TT(v[i]);\n }\n out << ']' << AnsiColor::normal;\n return out;\n}\n\n/**\n * \\ingroup Masks\n * \\headerfile IO \n *\n * Prints the contents of a mask into a stream object.\n *\n * \\code\n * const Vc::short_m m = Vc::short_v::IndexesFromZero() < 3;\n * std::cout << m << std::endl;\n * \\endcode\n * will output (with SSE):\n\\verbatim\nm[1110 0000]\n\\endverbatim\n *\n * \\param out Any standard C++ ostream object. For example std::cout or a\n * std::stringstream object.\n * \\param m Any Vc::Mask object.\n * \\return The ostream object: to chain multiple stream operations.\n *\n * \\note With the GNU standard library this function will check whether the\n * output stream is a tty in which case it colorizes the output.\n */\ntemplate \ninline std::ostream &operator<<(std::ostream &out, const Vc::Mask &m)\n{\n out << AnsiColor::blue << \"m[\";\n for (unsigned int i = 0; i < m.Size; ++i) {\n if (i > 0 && (i % 4) == 0) {\n out << ' ';\n }\n if (m[i]) {\n out << AnsiColor::yellow << '1';\n } else {\n out << AnsiColor::blue << '0';\n }\n }\n out << AnsiColor::blue << ']' << AnsiColor::normal;\n return out;\n}\n\nnamespace Common\n{\n#ifdef DOXYGEN\n/**\n * \\ingroup Utilities\n * \\headerfile dox.h \n *\n * Prints the contents of a Memory object into a stream object.\n *\n * \\code\n * Vc::Memory m;\n * for (int i = 0; i < m.entriesCount(); ++i) {\n * m[i] = i;\n * }\n * std::cout << m << std::endl;\n * \\endcode\n * will output (with SSE):\n\\verbatim\n{[0, 1, 2, 3] [4, 5, 6, 7] [8, 9, 0, 0]}\n\\endverbatim\n *\n * \\param s Any standard C++ ostream object. For example std::cout or a std::stringstream object.\n * \\param m Any Vc::Memory object.\n * \\return The ostream object: to chain multiple stream operations.\n *\n * \\note With the GNU standard library this function will check whether the\n * output stream is a tty in which case it colorizes the output.\n *\n * \\warning Please do not forget that printing a large memory object can take a long time.\n */\ntemplate\ninline std::ostream &operator<<(std::ostream &s, const Vc::MemoryBase &m);\n#endif\n\ntemplate\ninline std::ostream &operator<<(std::ostream &out, const MemoryBase &m )\n{\n out << AnsiColor::blue << '{' << AnsiColor::normal;\n for (unsigned int i = 0; i < m.vectorsCount(); ++i) {\n out << V(m.vector(i));\n }\n out << AnsiColor::blue << '}' << AnsiColor::normal;\n return out;\n}\n\ntemplate\ninline std::ostream &operator<<(std::ostream &out, const MemoryBase &m )\n{\n out << AnsiColor::blue << '{' << AnsiColor::normal;\n for (size_t i = 0; i < m.rowsCount(); ++i) {\n if (i > 0) {\n out << \"\\n \";\n }\n const size_t vcount = m[i].vectorsCount();\n for (size_t j = 0; j < vcount; ++j) {\n out << V(m[i].vector(j));\n }\n }\n out << AnsiColor::blue << '}' << AnsiColor::normal;\n return out;\n}\n} // namespace Common\n\ntemplate\ninline std::ostream &operator<<(std::ostream &out, const SimdArray &v)\n{\n out << AnsiColor::green << '<' << v[0];\n for (size_t i = 1; i < N; ++i) {\n if (i % 4 == 0) out << \" |\";\n out << ' ' << v[i];\n }\n return out << '>' << AnsiColor::normal;\n}\n\ntemplate\ninline std::ostream &operator<<(std::ostream &out, const SimdMaskArray &m)\n{\n out << AnsiColor::blue << \"«\";\n for (size_t i = 0; i < N; ++i) {\n if (i > 0 && (i % 4) == 0) {\n out << ' ';\n }\n if ( m[i] ) {\n out << AnsiColor::yellow << '1';\n } else {\n out << AnsiColor::blue << '0';\n }\n }\n return out << AnsiColor::blue << \"»\" << AnsiColor::normal;\n}\n}\n\n#endif // VC_IO_\n\n// vim: ft=cpp foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/Memory", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_MEMORY_\n#define VC_MEMORY_\n\n#include \"vector.h\"\n#include \"common/memory.h\"\n#include \"common/interleavedmemory.h\"\n\n#include \"common/make_unique.h\"\nnamespace Vc_VERSIONED_NAMESPACE\n{\nusing Common::make_unique;\n}\n\n#endif // VC_MEMORY_\n\n// vim: ft=cpp foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/SimdArray", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_SIMDARRAY_\n#define VC_SIMDARRAY_\n\n#include \"common/simdarray.h\"\n\n#endif // VC_SIMDARRAY_\n\n// vim: ft=cpp foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/Utils", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2010-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_UTILS_\n#define VC_UTILS_\n\n#include \"global.h\"\n\n#ifdef Vc_IMPL_Scalar\n# define VECTOR_NAMESPACE Scalar\n#else\n# define VECTOR_NAMESPACE SSE\n#endif\n\n#include \"common/deinterleave.h\"\n#include \"common/makeContainer.h\"\n\n#endif // VC_UTILS_\n\n// vim: ft=cpp foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/Vc", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_VC_\n#define VC_VC_\n#include \"vector.h\"\n#include \"IO\"\n#include \"Memory\"\n#include \"Utils\"\n#include \"Allocator\"\n#include \"algorithm\"\n#include \"iterators\"\n#include \"simdize\"\n#include \"array\"\n#include \"span\"\n#include \"vector\"\n#endif // VC_VC_\n\n// vim: ft=cpp foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/algorithm", "content": "#include \"common/algorithms.h\"\n" }, { "path": "3rdparty/Vc/Vc/array", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n//===---------------------------- array -----------------------------------===//\n//\n// The LLVM Compiler Infrastructure\n//\n// This file is dual licensed under the MIT and the University of Illinois Open\n// Source Licenses. See LICENSE.TXT for details.\n//\n//===----------------------------------------------------------------------===//\n\n#ifndef VC_INCLUDE_VC_ARRAY_\n#define VC_INCLUDE_VC_ARRAY_\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"common/subscript.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n/**\n * \\ingroup Containers\n * This is `std::array` with additional subscript operators supporting gather and scatter operations.\n *\n * The [std::array](https://en.cppreference.com/w/cpp/container/array) documentation applies.\n *\n * Gathers from structured data (AoS: arrays of struct) are possible via a special\n * subscript operator.\n * Example:\n * \\code\n * Vc::array data;\n * std::iota(data.begin(), data.end(), 0.f); // fill with values 0, 1, 2, ...\n * auto indexes = float_v::IndexType::IndexesFromZero();\n * float_v gathered = data[indexes]; // gathered == [0, 1, 2, ...]\n * \\endcode\n *\n * This also works for gathers into arrays of structures:\n * \\code\n * struct Point { float x, y, z; };\n * Vc::array points;\n * // fill points ...\n * auto indexes = float_v::IndexType::IndexesFromZero();\n * float_v xs = data[indexes][&Point::x]; // [points[0].x, points[1].x, points[2].x, ...]\n * float_v ys = data[indexes][&Point::y]; // [points[0].y, points[1].y, points[2].y, ...]\n * float_v zs = data[indexes][&Point::z]; // [points[0].z, points[1].z, points[2].z, ...]\n * \\endcode\n *\n * Arrays may also be nested:\n * \\code:\n * Vc::array, 100> points;\n * // fill points ...\n * auto indexes = float_v::IndexType::IndexesFromZero();\n * float_v xs = data[indexes][0]; // [points[0][0], points[1][0], points[2][0], ...]\n * float_v ys = data[indexes][1]; // [points[0][1], points[1][1], points[2][1], ...]\n * float_v zs = data[indexes][2]; // [points[0][2], points[1][2], points[2][2], ...]\n * \\endcode\n */\ntemplate struct array {\n // types:\n typedef array self_;\n typedef T value_type;\n typedef value_type& reference;\n typedef const value_type& const_reference;\n typedef value_type* iterator;\n typedef const value_type* const_iterator;\n typedef value_type* pointer;\n typedef const value_type* const_pointer;\n typedef size_t size_type;\n typedef ptrdiff_t difference_type;\n typedef std::reverse_iterator reverse_iterator;\n typedef std::reverse_iterator const_reverse_iterator;\n\n value_type elems_[Size > 0 ? Size : 1];\n\n // No explicit construct/copy/destroy for aggregate type\n void fill(const value_type& u_) { std::fill_n(elems_, Size, u_); }\n void swap(array& a_) noexcept(std::swap(std::declval(), std::declval()))\n {\n std::swap_ranges(elems_, elems_ + Size, a_.elems_);\n }\n\n // iterators:\n iterator begin() noexcept { return iterator(elems_); }\n const_iterator begin() const noexcept { return const_iterator(elems_); }\n iterator end() noexcept { return iterator(elems_ + Size); }\n const_iterator end() const noexcept { return const_iterator(elems_ + Size); }\n reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }\n const_reverse_iterator rbegin() const noexcept\n {\n return const_reverse_iterator(end());\n }\n reverse_iterator rend() noexcept { return reverse_iterator(begin()); }\n const_reverse_iterator rend() const noexcept\n {\n return const_reverse_iterator(begin());\n }\n\n const_iterator cbegin() const noexcept { return begin(); }\n const_iterator cend() const noexcept { return end(); }\n const_reverse_iterator crbegin() const noexcept { return rbegin(); }\n const_reverse_iterator crend() const noexcept { return rend(); }\n // capacity:\n constexpr size_type size() const noexcept { return Size; }\n constexpr size_type max_size() const noexcept { return Size; }\n constexpr bool empty() const noexcept { return Size == 0; }\n // element access:\n reference operator[](size_type n_) { return elems_[n_]; }\n constexpr const_reference operator[](size_type n_) const { return elems_[n_]; }\n\n /**\n * \\name Data-Parallel Subscripting for Gather & Scatter\n */\n ///@{\n template \n Vc_ALWAYS_INLINE auto operator[](I&& arg_)\n -> decltype(subscript_operator(*this, std::forward(arg_)))\n {\n return subscript_operator(*this, std::forward(arg_));\n }\n\n template \n Vc_ALWAYS_INLINE auto operator[](I&& arg_) const\n -> decltype(subscript_operator(*this, std::forward(arg_)))\n {\n return subscript_operator(*this, std::forward(arg_));\n }\n ///@}\n\n reference at(size_type n_);\n constexpr const_reference at(size_type n_) const;\n\n reference front() { return elems_[0]; }\n constexpr const_reference front() const { return elems_[0]; }\n reference back() { return elems_[Size > 0 ? Size - 1 : 0]; }\n constexpr const_reference back() const { return elems_[Size > 0 ? Size - 1 : 0]; }\n value_type* data() noexcept { return elems_; }\n const value_type* data() const noexcept { return elems_; }\n};\n\ntemplate \ntypename array::reference array::at(size_type n_)\n{\n if (n_ >= Size) {\n throw std::out_of_range(\"array::at\");\n }\n return elems_[n_];\n}\n\ntemplate \nconstexpr typename array::const_reference array::at(size_type n_) const\n{\n return n_ >= Size ? (throw std::out_of_range(\"array::at\"), elems_[0]) : elems_[n_];\n}\n\ntemplate \ninline bool operator==(const array& x_, const array& y_)\n{\n return std::equal(x_.elems_, x_.elems_ + Size, y_.elems_);\n}\n\ntemplate \ninline bool operator!=(const array& x_, const array& y_)\n{\n return !(x_ == y_);\n}\n\ntemplate \ninline bool operator<(const array& x_, const array& y_)\n{\n return std::lexicographical_compare(x_.elems_, x_.elems_ + Size, y_.elems_,\n y_.elems_ + Size);\n}\n\ntemplate \ninline bool operator>(const array& x_, const array& y_)\n{\n return y_ < x_;\n}\n\ntemplate \ninline bool operator<=(const array& x_, const array& y_)\n{\n return !(y_ < x_);\n}\n\ntemplate \ninline bool operator>=(const array& x_, const array& y_)\n{\n return !(x_ < y_);\n}\n\n/**\\name non-member begin & end\n * Implement the non-member begin & end functions in the %Vc namespace so that ADL works\n * and `begin(some_vc_array)` always works.\n */\n///@{\ntemplate \ninline auto begin(array& arr) -> decltype(arr.begin())\n{\n return arr.begin();\n}\ntemplate \ninline auto begin(const array& arr) -> decltype(arr.begin())\n{\n return arr.begin();\n}\ntemplate \ninline auto end(array& arr) -> decltype(arr.end())\n{\n return arr.end();\n}\ntemplate \ninline auto end(const array& arr) -> decltype(arr.end())\n{\n return arr.end();\n}\n///@}\n\nnamespace Traits\n{\ntemplate \nstruct has_no_allocated_data_impl> : public std::true_type\n{\n};\ntemplate \nstruct has_contiguous_storage_impl> : public std::true_type\n{\n};\n} // namespace Traits\n} // namespace Vc\n\nnamespace std\n{\ntemplate \ninline\n#ifdef Vc_MSVC\n // MSVC fails to do SFINAE correctly and gets totally confused:\n // error C2433: 'type': 'inline' not permitted on data declarations\n // error C4430: missing type specifier - int assumed. Note: C++ does not support default-int\n // error C2061: syntax error: identifier 'swap'\n void\n#else\n typename enable_if(), declval()))>::value,\n void>::type\n#endif\n swap(const Vc::array& x_,\n const Vc::array& y_) noexcept(swap(declval(), declval()))\n{\n x_.swap(y_);\n}\n\ntemplate \nclass tuple_size> : public integral_constant\n{\n};\n\ntemplate class tuple_element>\n{\npublic:\n typedef T type;\n};\n\ntemplate \ninline constexpr typename std::enable_if<(I < Size), T&>::type get(\n Vc::array& a_) noexcept\n{\n return a_.elems_[I];\n}\n\ntemplate \ninline constexpr typename std::enable_if<(I < Size), const T&>::type get(\n const Vc::array& a_) noexcept\n{\n return a_.elems_[I];\n}\n\ntemplate \ninline constexpr typename std::enable_if<(I < Size), T&&>::type get(\n Vc::array&& a_) noexcept\n{\n return std::move(a_.elems_[I]);\n}\n} // namespace std\n\n#endif // VC_INCLUDE_VC_ARRAY_\n\n// vim: ft=cpp foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/avx/casts.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_CASTS_H_\n#define VC_AVX_CASTS_H_\n\n#include \"intrinsics.h\"\n#include \"types.h\"\n#include \"../sse/casts.h\"\n#include \"shuffle.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AVX\n{\nnamespace Casts\n{\n template Vc_INTRINSIC_L T avx_cast(__m128 v) Vc_INTRINSIC_R;\n template Vc_INTRINSIC_L T avx_cast(__m128i v) Vc_INTRINSIC_R;\n template Vc_INTRINSIC_L T avx_cast(__m128d v) Vc_INTRINSIC_R;\n template Vc_INTRINSIC_L T avx_cast(__m256 v) Vc_INTRINSIC_R;\n template Vc_INTRINSIC_L T avx_cast(__m256i v) Vc_INTRINSIC_R;\n template Vc_INTRINSIC_L T avx_cast(__m256d v) Vc_INTRINSIC_R;\n\n // 128 -> 128\n template<> Vc_INTRINSIC __m128 avx_cast(__m128 v) { return v; }\n template<> Vc_INTRINSIC __m128 avx_cast(__m128i v) { return _mm_castsi128_ps(v); }\n template<> Vc_INTRINSIC __m128 avx_cast(__m128d v) { return _mm_castpd_ps(v); }\n template<> Vc_INTRINSIC __m128i avx_cast(__m128 v) { return _mm_castps_si128(v); }\n template<> Vc_INTRINSIC __m128i avx_cast(__m128i v) { return v; }\n template<> Vc_INTRINSIC __m128i avx_cast(__m128d v) { return _mm_castpd_si128(v); }\n template<> Vc_INTRINSIC __m128d avx_cast(__m128 v) { return _mm_castps_pd(v); }\n template<> Vc_INTRINSIC __m128d avx_cast(__m128i v) { return _mm_castsi128_pd(v); }\n template<> Vc_INTRINSIC __m128d avx_cast(__m128d v) { return v; }\n\n // 128 -> 256\n // FIXME: the following casts leave the upper 128bits undefined. With GCC and ICC I've never\n // seen the cast not do what I want though: after a VEX-coded SSE instruction the register's\n // upper 128bits are zero. Thus using the same register as AVX register will have the upper\n // 128bits zeroed. MSVC, though, implements _mm256_castxx128_xx256 with a 128bit move to memory\n // + 256bit load. Thus the upper 128bits are really undefined. But there is no intrinsic to do\n // what I want (i.e. alias the register, disallowing the move to memory in-between). I'm stuck,\n // do we really want to rely on specific compiler behavior here?\n template<> Vc_INTRINSIC __m256 avx_cast(__m128 v) { return _mm256_castps128_ps256(v); }\n template<> Vc_INTRINSIC __m256 avx_cast(__m128i v) { return _mm256_castps128_ps256(_mm_castsi128_ps(v)); }\n template<> Vc_INTRINSIC __m256 avx_cast(__m128d v) { return _mm256_castps128_ps256(_mm_castpd_ps(v)); }\n template<> Vc_INTRINSIC __m256i avx_cast(__m128 v) { return _mm256_castsi128_si256(_mm_castps_si128(v)); }\n template<> Vc_INTRINSIC __m256i avx_cast(__m128i v) { return _mm256_castsi128_si256(v); }\n template<> Vc_INTRINSIC __m256i avx_cast(__m128d v) { return _mm256_castsi128_si256(_mm_castpd_si128(v)); }\n template<> Vc_INTRINSIC __m256d avx_cast(__m128 v) { return _mm256_castpd128_pd256(_mm_castps_pd(v)); }\n template<> Vc_INTRINSIC __m256d avx_cast(__m128i v) { return _mm256_castpd128_pd256(_mm_castsi128_pd(v)); }\n template<> Vc_INTRINSIC __m256d avx_cast(__m128d v) { return _mm256_castpd128_pd256(v); }\n\n#if defined Vc_MSVC || defined Vc_CLANG || defined Vc_APPLECLANG\n static Vc_INTRINSIC Vc_CONST __m256 zeroExtend(__m128 v) { return _mm256_permute2f128_ps (_mm256_castps128_ps256(v), _mm256_castps128_ps256(v), 0x80); }\n static Vc_INTRINSIC Vc_CONST __m256i zeroExtend(__m128i v) { return _mm256_permute2f128_si256(_mm256_castsi128_si256(v), _mm256_castsi128_si256(v), 0x80); }\n static Vc_INTRINSIC Vc_CONST __m256d zeroExtend(__m128d v) { return _mm256_permute2f128_pd (_mm256_castpd128_pd256(v), _mm256_castpd128_pd256(v), 0x80); }\n#else\n static Vc_INTRINSIC Vc_CONST __m256 zeroExtend(__m128 v) { return _mm256_castps128_ps256(v); }\n static Vc_INTRINSIC Vc_CONST __m256i zeroExtend(__m128i v) { return _mm256_castsi128_si256(v); }\n static Vc_INTRINSIC Vc_CONST __m256d zeroExtend(__m128d v) { return _mm256_castpd128_pd256(v); }\n#endif\n\n // 256 -> 128\n template<> Vc_INTRINSIC __m128 avx_cast(__m256 v) { return _mm256_castps256_ps128(v); }\n template<> Vc_INTRINSIC __m128 avx_cast(__m256i v) { return _mm256_castps256_ps128(_mm256_castsi256_ps(v)); }\n template<> Vc_INTRINSIC __m128 avx_cast(__m256d v) { return _mm256_castps256_ps128(_mm256_castpd_ps(v)); }\n template<> Vc_INTRINSIC __m128i avx_cast(__m256 v) { return _mm256_castsi256_si128(_mm256_castps_si256(v)); }\n template<> Vc_INTRINSIC __m128i avx_cast(__m256i v) { return _mm256_castsi256_si128(v); }\n template<> Vc_INTRINSIC __m128i avx_cast(__m256d v) { return _mm256_castsi256_si128(_mm256_castpd_si256(v)); }\n template<> Vc_INTRINSIC __m128d avx_cast(__m256 v) { return _mm256_castpd256_pd128(_mm256_castps_pd(v)); }\n template<> Vc_INTRINSIC __m128d avx_cast(__m256i v) { return _mm256_castpd256_pd128(_mm256_castsi256_pd(v)); }\n template<> Vc_INTRINSIC __m128d avx_cast(__m256d v) { return _mm256_castpd256_pd128(v); }\n\n // 256 -> 256\n template<> Vc_INTRINSIC __m256 avx_cast(__m256 v) { return v; }\n template<> Vc_INTRINSIC __m256 avx_cast(__m256i v) { return _mm256_castsi256_ps(v); }\n template<> Vc_INTRINSIC __m256 avx_cast(__m256d v) { return _mm256_castpd_ps(v); }\n template<> Vc_INTRINSIC __m256i avx_cast(__m256 v) { return _mm256_castps_si256(v); }\n template<> Vc_INTRINSIC __m256i avx_cast(__m256i v) { return v; }\n template<> Vc_INTRINSIC __m256i avx_cast(__m256d v) { return _mm256_castpd_si256(v); }\n template<> Vc_INTRINSIC __m256d avx_cast(__m256 v) { return _mm256_castps_pd(v); }\n template<> Vc_INTRINSIC __m256d avx_cast(__m256i v) { return _mm256_castsi256_pd(v); }\n template<> Vc_INTRINSIC __m256d avx_cast(__m256d v) { return v; }\n\n // simplify splitting 256-bit registers in 128-bit registers\n Vc_INTRINSIC Vc_CONST __m128 lo128(__m256 v) { return avx_cast<__m128>(v); }\n Vc_INTRINSIC Vc_CONST __m128d lo128(__m256d v) { return avx_cast<__m128d>(v); }\n Vc_INTRINSIC Vc_CONST __m128i lo128(__m256i v) { return avx_cast<__m128i>(v); }\n Vc_INTRINSIC Vc_CONST __m128 hi128(__m256 v) { return extract128<1>(v); }\n Vc_INTRINSIC Vc_CONST __m128d hi128(__m256d v) { return extract128<1>(v); }\n Vc_INTRINSIC Vc_CONST __m128i hi128(__m256i v) { return extract128<1>(v); }\n\n // simplify combining 128-bit registers in 256-bit registers\n Vc_INTRINSIC Vc_CONST __m256 concat(__m128 a, __m128 b) { return insert128<1>(avx_cast<__m256 >(a), b); }\n Vc_INTRINSIC Vc_CONST __m256d concat(__m128d a, __m128d b) { return insert128<1>(avx_cast<__m256d>(a), b); }\n Vc_INTRINSIC Vc_CONST __m256i concat(__m128i a, __m128i b) { return insert128<1>(avx_cast<__m256i>(a), b); }\n\n} // namespace Casts\nusing namespace Casts;\n} // namespace AVX\n\nnamespace AVX2\n{\nusing namespace AVX::Casts;\n} // namespace AVX2\n\nnamespace AVX\n{\ntemplate struct ConvertTag {};\n\nVc_INTRINSIC __m256i convert(__m256 v, ConvertTag) { return _mm256_cvttps_epi32(v); }\nVc_INTRINSIC __m128i convert(__m256d v, ConvertTag) { return _mm256_cvttpd_epi32(v); }\nVc_INTRINSIC __m256i convert(__m256i v, ConvertTag) { return v; }\nVc_INTRINSIC __m256i convert(__m256i v, ConvertTag) { return v; }\nVc_INTRINSIC __m256i convert(__m128i v, ConvertTag) {\n#ifdef Vc_IMPL_AVX2\n return _mm256_cvtepi16_epi32(v);\n#else\n return AVX::srai_epi32<16>(\n concat(_mm_unpacklo_epi16(v, v), _mm_unpackhi_epi16(v, v)));\n#endif\n}\nVc_INTRINSIC __m256i convert(__m128i v, ConvertTag) {\n#ifdef Vc_IMPL_AVX2\n return _mm256_cvtepu16_epi32(v);\n#else\n return AVX::srli_epi32<16>(\n concat(_mm_unpacklo_epi16(v, v), _mm_unpackhi_epi16(v, v)));\n#endif\n}\n\nVc_INTRINSIC __m256i convert(__m256 v, ConvertTag) {\n using namespace AVX;\n return _mm256_castps_si256(_mm256_blendv_ps(\n _mm256_castsi256_ps(_mm256_cvttps_epi32(v)),\n _mm256_castsi256_ps(add_epi32(_mm256_cvttps_epi32(_mm256_sub_ps(v, set2power31_ps())),\n set2power31_epu32())),\n cmpge_ps(v, set2power31_ps())));\n}\nVc_INTRINSIC __m128i convert(__m256d v, ConvertTag) {\n using namespace AVX;\n return _mm_xor_si128(\n _mm256_cvttpd_epi32(_mm256_sub_pd(_mm256_floor_pd(v), set1_pd(0x80000000u))),\n _mm_set2power31_epu32());\n}\nVc_INTRINSIC __m256i convert(__m256i v, ConvertTag) { return v; }\nVc_INTRINSIC __m256i convert(__m256i v, ConvertTag) { return v; }\nVc_INTRINSIC __m256i convert(__m128i v, ConvertTag) {\n#ifdef Vc_IMPL_AVX2\n return _mm256_cvtepi16_epi32(v);\n#else\n return AVX::srai_epi32<16>(\n concat(_mm_unpacklo_epi16(v, v), _mm_unpackhi_epi16(v, v)));\n#endif\n}\nVc_INTRINSIC __m256i convert(__m128i v, ConvertTag) {\n#ifdef Vc_IMPL_AVX2\n return _mm256_cvtepu16_epi32(v);\n#else\n return AVX::srli_epi32<16>(\n concat(_mm_unpacklo_epi16(v, v), _mm_unpackhi_epi16(v, v)));\n#endif\n}\n\nVc_INTRINSIC __m256 convert(__m256 v, ConvertTag) { return v; }\nVc_INTRINSIC __m128 convert(__m256d v, ConvertTag) { return _mm256_cvtpd_ps(v); }\nVc_INTRINSIC __m256 convert(__m256i v, ConvertTag) { return _mm256_cvtepi32_ps(v); }\nVc_INTRINSIC __m256 convert(__m256i v, ConvertTag) {\n // this is complicated because cvtepi32_ps only supports signed input. Thus, all\n // input values with the MSB set would produce a negative result. We can reuse the\n // cvtepi32_ps instruction if we unset the MSB. But then the rounding results can be\n // different. Since float uses 24 bits for the mantissa (effectively), the 9-bit LSB\n // determines the rounding direction. (Consider the bits ...8'7654'3210. The bits [0:7]\n // need to be dropped and if > 0x80 round up, if < 0x80 round down. If [0:7] == 0x80\n // then the rounding direction is determined by bit [8] for round to even. That's why\n // the 9th bit is relevant for the rounding decision.)\n // If the MSB of the input is set to 0, the cvtepi32_ps instruction makes its rounding\n // decision on the lowest 8 bits instead. A second rounding decision is made when\n // float(0x8000'0000) is added. This will rarely fix the rounding issue.\n //\n // Here's what the standard rounding mode expects:\n // 0xc0000080 should cvt to 0xc0000000\n // 0xc0000081 should cvt to 0xc0000100\n // -- should cvt to 0xc0000100\n // 0xc000017f should cvt to 0xc0000100\n // 0xc0000180 should cvt to 0xc0000200\n //\n // However: using float(input ^ 0x8000'0000) + float(0x8000'0000) we get:\n // 0xc0000081 would cvt to 0xc0000000\n // 0xc00000c0 would cvt to 0xc0000000\n // 0xc00000c1 would cvt to 0xc0000100\n // 0xc000013f would cvt to 0xc0000100\n // 0xc0000140 would cvt to 0xc0000200\n //\n // Solution: float(input & 0x7fff'fe00) + (float(0x8000'0000) + float(input & 0x1ff))\n // This ensures the rounding decision is made on the 9-bit LSB when 0x8000'0000 is\n // added to the float value of the low 8 bits of the input.\n using namespace AVX;\n return _mm256_blendv_ps(\n _mm256_cvtepi32_ps(v),\n _mm256_add_ps(_mm256_cvtepi32_ps(and_si256(v, set1_epi32(0x7ffffe00))),\n _mm256_add_ps(set2power31_ps(), _mm256_cvtepi32_ps(and_si256(\n v, set1_epi32(0x000001ff))))),\n _mm256_castsi256_ps(cmplt_epi32(v, _mm256_setzero_si256())));\n}\nVc_INTRINSIC __m256 convert(__m128i v, ConvertTag) { return _mm256_cvtepi32_ps(convert(v, ConvertTag< short, int>())); }\nVc_INTRINSIC __m256 convert(__m128i v, ConvertTag) { return _mm256_cvtepi32_ps(convert(v, ConvertTag())); }\n\nVc_INTRINSIC __m256d convert(__m128 v, ConvertTag) { return _mm256_cvtps_pd(v); }\nVc_INTRINSIC __m256d convert(__m256d v, ConvertTag) { return v; }\nVc_INTRINSIC __m256d convert(__m128i v, ConvertTag) { return _mm256_cvtepi32_pd(v); }\nVc_INTRINSIC __m256d convert(__m128i v, ConvertTag) {\n using namespace AVX;\n return _mm256_add_pd(\n _mm256_cvtepi32_pd(_mm_xor_si128(v, _mm_setmin_epi32())),\n set1_pd(1u << 31)); }\nVc_INTRINSIC __m256d convert(__m128i v, ConvertTag) { return convert(convert(v, SSE::ConvertTag< short, int>()), ConvertTag()); }\nVc_INTRINSIC __m256d convert(__m128i v, ConvertTag) { return convert(convert(v, SSE::ConvertTag()), ConvertTag()); }\n\nVc_INTRINSIC __m128i convert(__m256i v, ConvertTag) {\n#ifdef Vc_IMPL_AVX2\n auto a = _mm256_shuffle_epi8(\n v, _mm256_setr_epi8(0, 1, 4, 5, 8, 9, 12, 13, -0x80, -0x80, -0x80, -0x80, -0x80,\n -0x80, -0x80, -0x80, 0, 1, 4, 5, 8, 9, 12, 13, -0x80, -0x80,\n -0x80, -0x80, -0x80, -0x80, -0x80, -0x80));\n return lo128(_mm256_permute4x64_epi64(a, 0xf8)); // a[0] a[2] | a[3] a[3]\n#else\n const auto tmp0 = _mm_unpacklo_epi16(lo128(v), hi128(v));\n const auto tmp1 = _mm_unpackhi_epi16(lo128(v), hi128(v));\n const auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);\n const auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);\n return _mm_unpacklo_epi16(tmp2, tmp3);\n#endif\n}\nVc_INTRINSIC __m128i convert(__m256i v, ConvertTag) { return convert(v, ConvertTag()); }\nVc_INTRINSIC __m128i convert(__m256 v, ConvertTag) { return convert(convert(v, ConvertTag()), ConvertTag()); }\nVc_INTRINSIC __m128i convert(__m256d v, ConvertTag) { return convert(convert(v, ConvertTag()), SSE::ConvertTag()); }\nVc_INTRINSIC __m256i convert(__m256i v, ConvertTag) { return v; }\nVc_INTRINSIC __m256i convert(__m256i v, ConvertTag) { return v; }\n\nVc_INTRINSIC __m128i convert(__m256i v, ConvertTag) {\n auto tmp0 = _mm_unpacklo_epi16(lo128(v), hi128(v));\n auto tmp1 = _mm_unpackhi_epi16(lo128(v), hi128(v));\n auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);\n auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);\n return _mm_unpacklo_epi16(tmp2, tmp3);\n}\nVc_INTRINSIC __m128i convert(__m256i v, ConvertTag) {\n auto tmp0 = _mm_unpacklo_epi16(lo128(v), hi128(v));\n auto tmp1 = _mm_unpackhi_epi16(lo128(v), hi128(v));\n auto tmp2 = _mm_unpacklo_epi16(tmp0, tmp1);\n auto tmp3 = _mm_unpackhi_epi16(tmp0, tmp1);\n return _mm_unpacklo_epi16(tmp2, tmp3);\n}\nVc_INTRINSIC __m128i convert(__m256 v, ConvertTag) { return convert(convert(v, ConvertTag()), ConvertTag()); }\nVc_INTRINSIC __m128i convert(__m256d v, ConvertTag) { return convert(convert(v, ConvertTag()), SSE::ConvertTag()); }\nVc_INTRINSIC __m256i convert(__m256i v, ConvertTag) { return v; }\nVc_INTRINSIC __m256i convert(__m256i v, ConvertTag) { return v; }\n\ntemplate \nVc_INTRINSIC auto convert(\n typename std::conditional<(sizeof(From) < sizeof(To)),\n typename SSE::VectorTraits::VectorType,\n typename AVX::VectorTypeHelper::Type>::type v)\n -> decltype(convert(v, ConvertTag()))\n{\n return convert(v, ConvertTag());\n}\n\ntemplate >\nVc_INTRINSIC auto convert(typename AVX::VectorTypeHelper::Type v)\n -> decltype(convert(lo128(v), ConvertTag()))\n{\n return convert(lo128(v), ConvertTag());\n}\n} // namespace AVX\n} // namespace Vc\n\n#endif // VC_AVX_CASTS_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/const.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_CONST_H_\n#define VC_AVX_CONST_H_\n\n#include \n#include \"types.h\"\n#include \"const_data.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AVX\n{\n template struct IndexesFromZeroData;\n template<> struct IndexesFromZeroData {\n static Vc_ALWAYS_INLINE Vc_CONST const int *address() { return reinterpret_cast(&_IndexesFromZero32[0]); }\n };\n template<> struct IndexesFromZeroData {\n static Vc_ALWAYS_INLINE Vc_CONST const unsigned int *address() { return &_IndexesFromZero32[0]; }\n };\n template<> struct IndexesFromZeroData {\n static Vc_ALWAYS_INLINE Vc_CONST const short *address() { return reinterpret_cast(&_IndexesFromZero16[0]); }\n };\n template<> struct IndexesFromZeroData {\n static Vc_ALWAYS_INLINE Vc_CONST const unsigned short *address() { return &_IndexesFromZero16[0]; }\n };\n template<> struct IndexesFromZeroData {\n static Vc_ALWAYS_INLINE Vc_CONST const signed char *address() { return reinterpret_cast(&_IndexesFromZero8[0]); }\n };\n template<> struct IndexesFromZeroData {\n static Vc_ALWAYS_INLINE Vc_CONST const char *address() { return reinterpret_cast(&_IndexesFromZero8[0]); }\n };\n template<> struct IndexesFromZeroData {\n static Vc_ALWAYS_INLINE Vc_CONST const unsigned char *address() { return &_IndexesFromZero8[0]; }\n };\n\n template struct Const\n {\n typedef Vector<_T> V;\n typedef typename V::EntryType T;\n typedef typename V::Mask M;\n\n static Vc_ALWAYS_INLINE Vc_CONST V _pi_4() { return V(c_trig::data[0]); }\n static Vc_ALWAYS_INLINE Vc_CONST V _pi_4_hi() { return V(c_trig::data[1]); }\n static Vc_ALWAYS_INLINE Vc_CONST V _pi_4_rem1() { return V(c_trig::data[2]); }\n static Vc_ALWAYS_INLINE Vc_CONST V _pi_4_rem2() { return V(c_trig::data[3]); }\n static Vc_ALWAYS_INLINE Vc_CONST V _1_16() { return V(c_trig::data[4]); }\n static Vc_ALWAYS_INLINE Vc_CONST V _16() { return V(c_trig::data[5]); }\n\n static Vc_ALWAYS_INLINE Vc_CONST V atanP(int i) { return V(c_trig::data[(12 + i)]); }\n static Vc_ALWAYS_INLINE Vc_CONST V atanQ(int i) { return V(c_trig::data[(17 + i)]); }\n static Vc_ALWAYS_INLINE Vc_CONST V atanThrsHi() { return V(c_trig::data[22]); }\n static Vc_ALWAYS_INLINE Vc_CONST V atanThrsLo() { return V(c_trig::data[23]); }\n static Vc_ALWAYS_INLINE Vc_CONST V _pi_2_rem() { return V(c_trig::data[24]); }\n static Vc_ALWAYS_INLINE Vc_CONST V lossThreshold() { return V(c_trig::data[8]); }\n static Vc_ALWAYS_INLINE Vc_CONST V _4_pi() { return V(c_trig::data[9]); }\n static Vc_ALWAYS_INLINE Vc_CONST V _pi_2() { return V(c_trig::data[10]); }\n static Vc_ALWAYS_INLINE Vc_CONST V _pi() { return V(c_trig::data[11]); }\n static Vc_ALWAYS_INLINE Vc_CONST V asinCoeff0(int i) { return V(c_trig::data[(28 + i)]); }\n static Vc_ALWAYS_INLINE Vc_CONST V asinCoeff1(int i) { return V(c_trig::data[(33 + i)]); }\n static Vc_ALWAYS_INLINE Vc_CONST V asinCoeff2(int i) { return V(c_trig::data[(37 + i)]); }\n static Vc_ALWAYS_INLINE Vc_CONST V asinCoeff3(int i) { return V(c_trig::data[(43 + i)]); }\n static Vc_ALWAYS_INLINE Vc_CONST V smallAsinInput() { return V(c_trig::data[25]); }\n static Vc_ALWAYS_INLINE Vc_CONST V largeAsinInput() { return V(c_trig::data[26]); }\n\n static Vc_ALWAYS_INLINE Vc_CONST M exponentMask() { return M(V(c_log::d(1)).data()); }\n static Vc_ALWAYS_INLINE Vc_CONST V _1_2() { return V(c_log::d(18)); }\n static Vc_ALWAYS_INLINE Vc_CONST V _1_sqrt2() { return V(c_log::d(15)); }\n static Vc_ALWAYS_INLINE Vc_CONST V P(int i) { return V(c_log::d(2 + i)); }\n static Vc_ALWAYS_INLINE Vc_CONST V Q(int i) { return V(c_log::d(8 + i)); }\n static Vc_ALWAYS_INLINE Vc_CONST V min() { return V(c_log::d(14)); }\n static Vc_ALWAYS_INLINE Vc_CONST V ln2_small() { return V(c_log::d(17)); }\n static Vc_ALWAYS_INLINE Vc_CONST V ln2_large() { return V(c_log::d(16)); }\n static Vc_ALWAYS_INLINE Vc_CONST V neginf() { return V(c_log::d(13)); }\n static Vc_ALWAYS_INLINE Vc_CONST V log10_e() { return V(c_log::d(19)); }\n static Vc_ALWAYS_INLINE Vc_CONST V log2_e() { return V(c_log::d(20)); }\n\n static Vc_ALWAYS_INLINE_L Vc_CONST_L V highMask() Vc_ALWAYS_INLINE_R Vc_CONST_R;\n static Vc_ALWAYS_INLINE_L Vc_CONST_L V highMask(int bits) Vc_ALWAYS_INLINE_R Vc_CONST_R;\n };\n\n template <> Vc_ALWAYS_INLINE Vc_CONST Vector Const::highMask()\n {\n return _mm256_broadcast_ss(\n reinterpret_cast(&c_general::highMaskFloat));\n }\n template <> Vc_ALWAYS_INLINE Vc_CONST Vector Const::highMask()\n {\n return _mm256_broadcast_sd(\n reinterpret_cast(&c_general::highMaskDouble));\n }\n template <> Vc_ALWAYS_INLINE Vc_CONST Vector Const::highMask(int bits)\n {\n#ifdef Vc_IMPL_AVX2\n#if defined Vc_ICC || defined Vc_MSVC\n __m256i allone = _mm256_set1_epi64x(~0);\n#else\n auto allone = ~__m256i();\n#endif\n return _mm256_castsi256_ps(_mm256_slli_epi32(allone, bits));\n#else\n __m128 tmp = _mm_castsi128_ps(_mm_slli_epi32(_mm_setallone_si128(), bits));\n return concat(tmp, tmp);\n#endif\n }\n template <> Vc_ALWAYS_INLINE Vc_CONST Vector Const::highMask(int bits)\n {\n#ifdef Vc_IMPL_AVX2\n#if defined Vc_ICC || defined Vc_MSVC\n __m256i allone = _mm256_set1_epi64x(~0);\n#else\n auto allone = ~__m256i();\n#endif\n return _mm256_castsi256_pd(_mm256_slli_epi64(allone, bits));\n#else\n __m128d tmp = _mm_castsi128_pd(_mm_slli_epi64(_mm_setallone_si128(), bits));\n return concat(tmp, tmp);\n#endif\n }\n} // namespace AVX\n\nnamespace AVX2\n{\nusing AVX::IndexesFromZeroData;\nusing AVX::Const;\n} // namespace AVX2\n} // namespace Vc\n\n#endif // VC_AVX_CONST_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/const_data.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2012-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_CONST_DATA_H_\n#define VC_AVX_CONST_DATA_H_\n\n#include \"../common/data.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AVX\n{\n\nalignas(64) extern const unsigned int _IndexesFromZero32[ 8];\nalignas(16) extern const unsigned short _IndexesFromZero16[16];\nalignas(16) extern const unsigned char _IndexesFromZero8 [32];\n\nstruct alignas(64) c_general\n{\n static const float oneFloat;\n static const unsigned int absMaskFloat[2];\n static const unsigned int signMaskFloat[2];\n static const unsigned int highMaskFloat;\n static const unsigned short minShort[2];\n static const unsigned short one16[2];\n static const float _2power31;\n static const double oneDouble;\n static const unsigned long long frexpMask;\n static const unsigned long long highMaskDouble;\n};\n\ntemplate struct c_trig\n{\n alignas(64) static const T data[];\n};\n#ifndef Vc_MSVC\ntemplate <> alignas(64) const float c_trig::data[];\ntemplate <> alignas(64) const double c_trig::data[];\n#endif\n\ntemplate struct c_log\n{\n typedef float floatAlias Vc_MAY_ALIAS;\n static Vc_ALWAYS_INLINE float d(int i) { return *reinterpret_cast(&data[i]); }\n alignas(64) static const unsigned int data[21];\n};\n#ifndef Vc_MSVC\ntemplate<> alignas(64) const unsigned int c_log::data[21];\n#endif\n\ntemplate<> struct c_log\n{\n enum VectorSize { Size = 16 / sizeof(double) };\n typedef double doubleAlias Vc_MAY_ALIAS;\n static Vc_ALWAYS_INLINE double d(int i) { return *reinterpret_cast(&data[i]); }\n alignas(64) static const unsigned long long data[21];\n};\n\n} // namespace AVX\n} // namespace Vc\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AVX2\n{\n using AVX::_IndexesFromZero8;\n using AVX::_IndexesFromZero16;\n using AVX::_IndexesFromZero32;\n using AVX::c_general;\n using AVX::c_trig;\n using AVX::c_log;\n} // namespace AVX2\n} // namespace Vc\n\n#endif // VC_AVX_CONST_DATA_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/debug.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2011-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_DEBUG_H_\n#define VC_AVX_DEBUG_H_\n\n#ifndef NDEBUG\n#include \"vector.h\"\n#include \n#include \n#endif\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AVX\n{\ntemplate struct AddType {\n const U &d;\n};\ntemplate AddType addType(const U &x) { return {x}; }\n\n#ifdef NDEBUG\nclass DebugStream\n{\n public:\n DebugStream(const char *, const char *, int) {}\n template inline DebugStream &operator<<(const T &) { return *this; }\n};\n#else\nclass DebugStream\n{\n private:\n template static void printVector(V _x)\n {\n enum { Size = sizeof(V) / sizeof(T) };\n union { V v; T m[Size]; } x = { _x };\n std::cerr << '[' << std::setprecision(24) << x.m[0];\n for (int i = 1; i < Size; ++i) {\n std::cerr << \", \" << std::setprecision(24) << x.m[i];\n }\n std::cerr << ']';\n }\n public:\n DebugStream(const char *func, const char *file, int line)\n {\n std::cerr << \"\\033[1;40;33mDEBUG: \" << file << ':' << line << ' ' << func << ' ';\n }\n\n template DebugStream &operator<<(const T &x) { std::cerr << x; return *this; }\n\n template DebugStream &operator<<(AddType &&x)\n {\n printVector(x.d);\n return *this;\n }\n DebugStream &operator<<(__m128 x) {\n printVector(x);\n return *this;\n }\n DebugStream &operator<<(__m256 x) {\n printVector(x);\n return *this;\n }\n DebugStream &operator<<(__m128d x) {\n printVector(x);\n return *this;\n }\n DebugStream &operator<<(__m256d x) {\n printVector(x);\n return *this;\n }\n DebugStream &operator<<(__m128i x) {\n printVector(x);\n return *this;\n }\n DebugStream &operator<<(__m256i x) {\n printVector(x);\n return *this;\n }\n\n ~DebugStream()\n {\n std::cerr << \"\\033[0m\" << std::endl;\n }\n};\n#endif\n\n#ifdef Vc_DEBUG\n#undef Vc_DEBUG\n#endif\n#ifdef Vc_MSVC\n#define Vc_DEBUG Vc::AVX::DebugStream(__FUNCSIG__, __FILE__, __LINE__)\n#else\n#define Vc_DEBUG Vc::AVX::DebugStream(__PRETTY_FUNCTION__, __FILE__, __LINE__)\n#endif\n\n} // namespace AVX\n} // namespace Vc\n\n#endif // VC_AVX_DEBUG_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/deinterleave.tcc", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2010-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AVX2\n{\n\ninline void deinterleave(double_v &Vc_RESTRICT a, double_v &Vc_RESTRICT b, double_v &Vc_RESTRICT c)\n{ // estimated latency (AVX): 4.5 cycles\n const m256d tmp0 = Mem::shuffle128(a.data(), b.data());\n const m256d tmp1 = Mem::shuffle128(a.data(), c.data());\n const m256d tmp2 = Mem::shuffle128(b.data(), c.data());\n a.data() = Mem::shuffle(tmp0, tmp1);\n b.data() = Mem::shuffle(tmp0, tmp2);\n c.data() = Mem::shuffle(tmp1, tmp2);\n}\n\ninline void deinterleave(float_v &Vc_RESTRICT a, float_v &Vc_RESTRICT b, float_v &Vc_RESTRICT c)\n{\n // abc abc abc\n // a = [a0 b0 c0 a1 b1 c1 a2 b2] 332 = 211+121\n // b = [c2 a3 b3 c3 a4 b4 c4 a5] 323 = 112+211\n // c = [b5 c5 a6 b6 c6 a7 b7 c7] 233 = 121+112\n const m256 ac0 = Mem::shuffle128(a.data(), c.data()); // a0 b0 c0 a1 b5 c5 a6 b6\n const m256 ac1 = Mem::shuffle128(a.data(), c.data()); // b1 c1 a2 b2 c6 a7 b7 c7\n\n m256 tmp0 = Mem::blend( ac0, b.data());\n tmp0 = Mem::blend(tmp0, ac1); // a0 a3 a2 a1 a4 a7 a6 a5\n m256 tmp1 = Mem::blend( ac0, b.data());\n tmp1 = Mem::blend(tmp1, ac1); // b1 b0 b3 b2 b5 b4 b7 b6\n m256 tmp2 = Mem::blend( ac0, b.data());\n tmp2 = Mem::blend(tmp2, ac1); // c2 c1 c0 c3 c6 c5 c4 c7\n\n a.data() = Mem::permute(tmp0);\n b.data() = Mem::permute(tmp1);\n c.data() = Mem::permute(tmp2);\n}\n\ninline void deinterleave(int_v &Vc_RESTRICT a, int_v &Vc_RESTRICT b, int_v &Vc_RESTRICT c)\n{\n deinterleave(reinterpret_cast(a), reinterpret_cast(b),\n reinterpret_cast(c));\n}\n\ninline void deinterleave(uint_v &Vc_RESTRICT a, uint_v &Vc_RESTRICT b, uint_v &Vc_RESTRICT c)\n{\n deinterleave(reinterpret_cast(a), reinterpret_cast(b),\n reinterpret_cast(c));\n}\n\ninline void deinterleave(Vector &Vc_RESTRICT , Vector &Vc_RESTRICT ,\n Vector &Vc_RESTRICT )\n{\n return;\n /* TODO:\n // abc abc abc\n // a = [a0 b0 c0 a1 b1 c1 a2 b2] 332 = 211+121\n // b = [c2 a3 b3 c3 a4 b4 c4 a5] 323 = 112+211\n // c = [b5 c5 a6 b6 c6 a7 b7 c7] 233 = 121+112\n m128i ac0 = _mm_unpacklo_epi64(a.data(), c.data()); // a0 b0 c0 a1 b5 c5 a6 b6\n m128i ac1 = _mm_unpackhi_epi64(a.data(), c.data()); // b1 c1 a2 b2 c6 a7 b7 c7\n\n m128i tmp0 = Mem::blend( ac0, b.data());\n tmp0 = Mem::blend(tmp0, ac1); // a0 a3 a2 a1 a4 a7 a6 a5\n m128i tmp1 = Mem::blend( ac0, b.data());\n tmp1 = Mem::blend(tmp1, ac1); // b1 b0 b3 b2 b5 b4 b7 b6\n m128i tmp2 = Mem::blend( ac0, b.data());\n tmp2 = Mem::blend(tmp2, ac1); // c2 c1 c0 c3 c6 c5 c4 c7\n\n a.data() = Mem::permuteHi(Mem::permuteLo(tmp0));\n b.data() = Mem::permuteHi(Mem::permuteLo(tmp1));\n c.data() = Mem::permuteHi(Mem::permuteLo(tmp2));\n */\n}\n\ninline void deinterleave(Vector &Vc_RESTRICT a, Vector &Vc_RESTRICT b,\n Vector &Vc_RESTRICT c)\n{\n deinterleave(reinterpret_cast &>(a), reinterpret_cast &>(b),\n reinterpret_cast &>(c));\n}\n\ninline void deinterleave(Vector &a, Vector &b)\n{\n // a7 a6 a5 a4 a3 a2 a1 a0\n // b7 b6 b5 b4 b3 b2 b1 b0\n const m256 tmp0 = Reg::permute128(a.data(), b.data()); // b3 b2 b1 b0 a3 a2 a1 a0\n const m256 tmp1 = Reg::permute128(a.data(), b.data()); // b7 b6 b5 b4 a7 a6 a5 a4\n\n const m256 tmp2 = _mm256_unpacklo_ps(tmp0, tmp1); // b5 b1 b4 b0 a5 a1 a4 a0\n const m256 tmp3 = _mm256_unpackhi_ps(tmp0, tmp1); // b7 b3 b6 b2 a7 a3 a6 a2\n\n a.data() = _mm256_unpacklo_ps(tmp2, tmp3); // b6 b4 b2 b0 a6 a4 a2 a0\n b.data() = _mm256_unpackhi_ps(tmp2, tmp3); // b7 b5 b3 b1 a7 a5 a3 a1\n}\n\ninline void deinterleave(Vector &a, // a0 b0 a1 b1 a2 b2 a3 b3 | a4 b4 a5 ...\n Vector &b) // a8 b8 a9 ...\n{\n auto v0 = Mem::shuffle128(a.data(), b.data());\n auto v1 = Mem::shuffle128(a.data(), b.data());\n auto v2 = AVX::unpacklo_epi16(v0, v1); // a0 a4 ...\n auto v3 = AVX::unpackhi_epi16(v0, v1); // a2 a6 ...\n v0 = AVX::unpacklo_epi16(v2, v3); // a0 a2 ...\n v1 = AVX::unpackhi_epi16(v2, v3); // a1 a3 ...\n a.data() = AVX::unpacklo_epi16(v0, v1); // a0 a1 ...\n b.data() = AVX::unpackhi_epi16(v0, v1); // b0 b1 ...\n}\n\ninline void deinterleave(Vector &a, Vector &b)\n{\n auto v0 = Mem::shuffle128(a.data(), b.data());\n auto v1 = Mem::shuffle128(a.data(), b.data());\n auto v2 = AVX::unpacklo_epi16(v0, v1); // a0 a4 ...\n auto v3 = AVX::unpackhi_epi16(v0, v1); // a2 a6 ...\n v0 = AVX::unpacklo_epi16(v2, v3); // a0 a2 ...\n v1 = AVX::unpackhi_epi16(v2, v3); // a1 a3 ...\n a.data() = AVX::unpacklo_epi16(v0, v1); // a0 a1 ...\n b.data() = AVX::unpackhi_epi16(v0, v1); // b0 b1 ...\n}\n\n} // namespace AVX2\nnamespace Detail\n{\ntemplate \ninline void deinterleave(AVX2::float_v &a, AVX2::float_v &b, const float *m, Flags align)\n{\n a.load(m, align);\n b.load(m + AVX2::float_v::Size, align);\n Vc::AVX2::deinterleave(a, b);\n}\n\ntemplate \ninline void deinterleave(AVX2::float_v &a, AVX2::float_v &b, const short *m, Flags f)\n{\n using namespace Vc::AVX2;\n const auto tmp = Detail::load32(m, f);\n a.data() =\n _mm256_cvtepi32_ps(concat(_mm_srai_epi32(_mm_slli_epi32(lo128(tmp), 16), 16),\n _mm_srai_epi32(_mm_slli_epi32(hi128(tmp), 16), 16)));\n b.data() = _mm256_cvtepi32_ps(\n concat(_mm_srai_epi32(lo128(tmp), 16), _mm_srai_epi32(hi128(tmp), 16)));\n}\n\ntemplate \ninline void deinterleave(AVX2::float_v &a, AVX2::float_v &b, const unsigned short *m, Flags f)\n{\n using namespace Vc::AVX2;\n const auto tmp = Detail::load32(m, f);\n a.data() = _mm256_cvtepi32_ps(\n concat(_mm_blend_epi16(lo128(tmp), _mm_setzero_si128(), 0xaa),\n _mm_blend_epi16(hi128(tmp), _mm_setzero_si128(), 0xaa)));\n b.data() = _mm256_cvtepi32_ps(\n concat(_mm_srli_epi32(lo128(tmp), 16), _mm_srli_epi32(hi128(tmp), 16)));\n}\n\ntemplate \ninline void deinterleave(AVX2::double_v &a, AVX2::double_v &b, const double *m, Flags align)\n{\n using namespace Vc::AVX2;\n\n a.load(m, align);\n b.load(m + AVX2::double_v::Size, align);\n\n m256d tmp0 = Mem::shuffle128(a.data(), b.data()); // b1 b0 a1 a0\n m256d tmp1 = Mem::shuffle128(a.data(), b.data()); // b3 b2 a3 a2\n\n a.data() = _mm256_unpacklo_pd(tmp0, tmp1); // b2 b0 a2 a0\n b.data() = _mm256_unpackhi_pd(tmp0, tmp1); // b3 b1 a3 a1\n}\n\ntemplate \ninline void deinterleave(AVX2::int_v &a, AVX2::int_v &b, const int *m, Flags align)\n{\n using namespace AVX;\n a.load(m, align);\n b.load(m + AVX2::int_v::Size, align);\n\n const m256 tmp0 = avx_cast(Mem::shuffle128(a.data(), b.data()));\n const m256 tmp1 = avx_cast(Mem::shuffle128(a.data(), b.data()));\n\n const m256 tmp2 = _mm256_unpacklo_ps(tmp0, tmp1); // b5 b1 b4 b0 a5 a1 a4 a0\n const m256 tmp3 = _mm256_unpackhi_ps(tmp0, tmp1); // b7 b3 b6 b2 a7 a3 a6 a2\n\n a.data() = avx_cast(_mm256_unpacklo_ps(tmp2, tmp3)); // b6 b4 b2 b0 a6 a4 a2 a0\n b.data() = avx_cast(_mm256_unpackhi_ps(tmp2, tmp3)); // b7 b5 b3 b1 a7 a5 a3 a1\n}\n\ntemplate \ninline void deinterleave(AVX2::int_v &a, AVX2::int_v &b, const short *m, Flags f)\n{\n using namespace Vc::AVX;\n const AVX2::short_v tmp0(m, f);\n const m256i tmp = tmp0.data();\n a.data() = concat(\n _mm_srai_epi32(_mm_slli_epi32(lo128(tmp), 16), 16),\n _mm_srai_epi32(_mm_slli_epi32(hi128(tmp), 16), 16));\n b.data() = concat(\n _mm_srai_epi32(lo128(tmp), 16),\n _mm_srai_epi32(hi128(tmp), 16));\n}\n\ntemplate \ninline void deinterleave(AVX2::uint_v &a, AVX2::uint_v &b, const unsigned int *m, Flags align)\n{\n using namespace AVX;\n a.load(m, align);\n b.load(m + AVX2::uint_v::Size, align);\n\n const m256 tmp0 = avx_cast(Mem::shuffle128(a.data(), b.data()));\n const m256 tmp1 = avx_cast(Mem::shuffle128(a.data(), b.data()));\n\n const m256 tmp2 = _mm256_unpacklo_ps(tmp0, tmp1); // b5 b1 b4 b0 a5 a1 a4 a0\n const m256 tmp3 = _mm256_unpackhi_ps(tmp0, tmp1); // b7 b3 b6 b2 a7 a3 a6 a2\n\n a.data() = avx_cast(_mm256_unpacklo_ps(tmp2, tmp3)); // b6 b4 b2 b0 a6 a4 a2 a0\n b.data() = avx_cast(_mm256_unpackhi_ps(tmp2, tmp3)); // b7 b5 b3 b1 a7 a5 a3 a1\n}\n\ntemplate \ninline void deinterleave(AVX2::uint_v &a, AVX2::uint_v &b, const unsigned short *m, Flags f)\n{\n using namespace Vc::AVX;\n const AVX2::ushort_v tmp0(m, f);\n const m256i tmp = tmp0.data();\n a.data() = concat(\n _mm_srai_epi32(_mm_slli_epi32(lo128(tmp), 16), 16),\n _mm_srai_epi32(_mm_slli_epi32(hi128(tmp), 16), 16));\n b.data() = concat(\n _mm_srai_epi32(lo128(tmp), 16),\n _mm_srai_epi32(hi128(tmp), 16));\n}\n\ntemplate \ninline void deinterleave(AVX2::short_v &a, AVX2::short_v &b, const short *m, Flags align)\n{\n a.load(m, align);\n b.load(m + AVX2::short_v::Size, align);\n Vc::AVX2::deinterleave(a, b);\n}\n\ntemplate \ninline void deinterleave(AVX2::ushort_v &a, AVX2::ushort_v &b, const unsigned short *m, Flags align)\n{\n a.load(m, align);\n b.load(m + AVX2::ushort_v::Size, align);\n Vc::AVX2::deinterleave(a, b);\n}\n\n// only support M == V::EntryType -> no specialization\ntemplate \nVc_ALWAYS_INLINE void deinterleave(AVX2::Vector &Vc_RESTRICT a,\n AVX2::Vector &Vc_RESTRICT b,\n AVX2::Vector &Vc_RESTRICT c,\n const M *Vc_RESTRICT memory, Flags align)\n{\n using V = AVX2::Vector;\n a.load(&memory[0 * V::Size], align);\n b.load(&memory[1 * V::Size], align);\n c.load(&memory[2 * V::Size], align);\n Vc::AVX2::deinterleave(a, b, c);\n}\n\n} // namespace Detail\n} // namespace Vc\n" }, { "path": "3rdparty/Vc/Vc/avx/detail.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_DETAIL_H_\n#define VC_AVX_DETAIL_H_\n\n#include \"../sse/detail.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Detail\n{\n// (converting) load functions {{{1\ntemplate \nVc_INTRINSIC Vc_PURE __m256 load(const float *x, Flags, LoadTag<__m256, float>,\n typename Flags::EnableIfAligned = nullptr)\n{\n return _mm256_load_ps(x);\n}\ntemplate \nVc_INTRINSIC Vc_PURE __m256 load(const float *x, Flags, LoadTag<__m256, float>,\n typename Flags::EnableIfUnaligned = nullptr)\n{\n return _mm256_loadu_ps(x);\n}\ntemplate \nVc_INTRINSIC Vc_PURE __m256 load(const float *x, Flags, LoadTag<__m256, float>,\n typename Flags::EnableIfStreaming = nullptr)\n{\n return AvxIntrinsics::stream_load<__m256>(x);\n}\n\ntemplate \nVc_INTRINSIC Vc_PURE __m256d load(const double *x, Flags, LoadTag<__m256d, double>,\n typename Flags::EnableIfAligned = nullptr)\n{\n return _mm256_load_pd(x);\n}\ntemplate \nVc_INTRINSIC Vc_PURE __m256d load(const double *x, Flags, LoadTag<__m256d, double>,\n typename Flags::EnableIfUnaligned = nullptr)\n{\n return _mm256_loadu_pd(x);\n}\ntemplate \nVc_INTRINSIC Vc_PURE __m256d load(const double *x, Flags, LoadTag<__m256d, double>,\n typename Flags::EnableIfStreaming = nullptr)\n{\n return AvxIntrinsics::stream_load<__m256d>(x);\n}\n\ntemplate ::value>>\nVc_INTRINSIC Vc_PURE __m256i\nload(const T *x, Flags, LoadTag<__m256i, T>, typename Flags::EnableIfAligned = nullptr)\n{\n return _mm256_load_si256(reinterpret_cast(x));\n}\ntemplate ::value>>\nVc_INTRINSIC Vc_PURE __m256i\nload(const T *x, Flags, LoadTag<__m256i, T>, typename Flags::EnableIfUnaligned = nullptr)\n{\n return _mm256_loadu_si256(reinterpret_cast(x));\n}\ntemplate ::value>>\nVc_INTRINSIC Vc_PURE __m256i\nload(const T *x, Flags, LoadTag<__m256i, T>, typename Flags::EnableIfStreaming = nullptr)\n{\n return AvxIntrinsics::stream_load<__m256i>(x);\n}\n\n// load32{{{2\nVc_INTRINSIC __m256 load32(const float *mem, when_aligned)\n{\n return _mm256_load_ps(mem);\n}\nVc_INTRINSIC __m256 load32(const float *mem, when_unaligned)\n{\n return _mm256_loadu_ps(mem);\n}\nVc_INTRINSIC __m256 load32(const float *mem, when_streaming)\n{\n return AvxIntrinsics::stream_load<__m256>(mem);\n}\nVc_INTRINSIC __m256d load32(const double *mem, when_aligned)\n{\n return _mm256_load_pd(mem);\n}\nVc_INTRINSIC __m256d load32(const double *mem, when_unaligned)\n{\n return _mm256_loadu_pd(mem);\n}\nVc_INTRINSIC __m256d load32(const double *mem, when_streaming)\n{\n return AvxIntrinsics::stream_load<__m256d>(mem);\n}\ntemplate Vc_INTRINSIC __m256i load32(const T *mem, when_aligned)\n{\n static_assert(std::is_integral::value, \"load32 is only intended for integral T\");\n return _mm256_load_si256(reinterpret_cast(mem));\n}\ntemplate Vc_INTRINSIC __m256i load32(const T *mem, when_unaligned)\n{\n static_assert(std::is_integral::value, \"load32 is only intended for integral T\");\n return _mm256_loadu_si256(reinterpret_cast(mem));\n}\ntemplate Vc_INTRINSIC __m256i load32(const T *mem, when_streaming)\n{\n static_assert(std::is_integral::value, \"load32 is only intended for integral T\");\n return AvxIntrinsics::stream_load<__m256i>(mem);\n}\n\n// MSVC workarounds{{{2\n#ifdef Vc_MSVC\n// work around: \"fatal error C1001: An internal error has occurred in the compiler.\"\nVc_INTRINSIC __m256i load(const uint *mem, when_aligned, LoadTag<__m256i, int>)\n{\n return _mm256_load_si256(reinterpret_cast(mem));\n}\n\nVc_INTRINSIC __m256d load(const double *mem, when_unaligned, LoadTag<__m256d, double>)\n{\n return _mm256_loadu_pd(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256 load(const float *mem, when_aligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_load_ps(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256 load(const float *mem, when_unaligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_loadu_ps(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256 load(const float *mem, when_streaming,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return AvxIntrinsics::stream_load<__m256>(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256d load(const double *mem, when_aligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_load_pd(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256d load(const double *mem, when_unaligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_loadu_pd(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256d load(const double *mem, when_streaming,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return AvxIntrinsics::stream_load<__m256d>(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const uint *mem, when_aligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_load_si256(reinterpret_cast(mem));\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const uint *mem, when_unaligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_loadu_si256(reinterpret_cast(mem));\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const uint *mem, when_streaming,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return AvxIntrinsics::stream_load<__m256i>(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const int *mem, when_unaligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_loadu_si256(reinterpret_cast(mem));\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const int *mem, when_aligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_load_si256(reinterpret_cast(mem));\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const int *mem, when_streaming,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return AvxIntrinsics::stream_load<__m256i>(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const short *mem, when_unaligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_loadu_si256(reinterpret_cast(mem));\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const short *mem, when_aligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_load_si256(reinterpret_cast(mem));\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const short *mem, when_streaming,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return AvxIntrinsics::stream_load<__m256i>(mem);\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const ushort *mem, when_unaligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_loadu_si256(reinterpret_cast(mem));\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const ushort *mem, when_aligned,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return _mm256_load_si256(reinterpret_cast(mem));\n}\n\ntemplate \nVc_INTRINSIC __m256i load(const ushort *mem, when_streaming,\n enable_if<(std::is_same::value &&\n std::is_same::value)> = nullarg)\n{\n return AvxIntrinsics::stream_load<__m256i>(mem);\n}\n\n#endif // Vc_MSVC\n\n// short {{{2\ntemplate \nVc_INTRINSIC __m256i load(const ushort *mem, Flags f, LoadTag<__m256i, short>)\n{\n return load32(mem, f);\n}\ntemplate \nVc_INTRINSIC __m256i load(const uchar *mem, Flags f, LoadTag<__m256i, short>)\n{\n return AVX::cvtepu8_epi16(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256i load(const schar *mem, Flags f, LoadTag<__m256i, short>)\n{\n return AVX::cvtepi8_epi16(load16(mem, f));\n}\n\n// ushort {{{2\ntemplate \nVc_INTRINSIC __m256i load(const uchar *mem, Flags f, LoadTag<__m256i, ushort>)\n{\n return AVX::cvtepu8_epi16(load16(mem, f));\n}\n\n// int {{{2\ntemplate \nVc_INTRINSIC __m256i load(const uint *mem, Flags f, LoadTag<__m256i, int>)\n{\n return load32(mem, f);\n}\ntemplate \nVc_INTRINSIC __m256i load(const ushort *mem, Flags f, LoadTag<__m256i, int>)\n{\n return AVX::cvtepu16_epi32(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256i load(const short *mem, Flags f, LoadTag<__m256i, int>)\n{\n return AVX::cvtepi16_epi32(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256i load(const uchar *mem, Flags, LoadTag<__m256i, int>)\n{\n return AVX::cvtepu8_epi32(_mm_loadl_epi64(reinterpret_cast(mem)));\n}\ntemplate \nVc_INTRINSIC __m256i load(const schar *mem, Flags, LoadTag<__m256i, int>)\n{\n return AVX::cvtepi8_epi32(_mm_loadl_epi64(reinterpret_cast(mem)));\n}\n\n// uint {{{2\ntemplate \nVc_INTRINSIC __m256i load(const ushort *mem, Flags f, LoadTag<__m256i, uint>)\n{\n return AVX::cvtepu16_epi32(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256i load(const uchar *mem, Flags, LoadTag<__m256i, uint>)\n{\n return AVX::cvtepu8_epi32(_mm_loadl_epi64(reinterpret_cast(mem)));\n}\n\n// double {{{2\ntemplate \nVc_INTRINSIC __m256d load(const float *mem, Flags f, LoadTag<__m256d, double>)\n{\n return AVX::convert(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256d load(const uint *mem, Flags f, LoadTag<__m256d, double>)\n{\n return AVX::convert(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256d load(const int *mem, Flags f, LoadTag<__m256d, double>)\n{\n return AVX::convert(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256d load(const ushort *mem, Flags f, LoadTag<__m256d, double>)\n{\n return AVX::convert(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256d load(const short *mem, Flags f, LoadTag<__m256d, double>)\n{\n return AVX::convert(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256d load(const uchar *mem, Flags f, LoadTag<__m256d, double>)\n{\n return AVX::convert(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256d load(const schar *mem, Flags f, LoadTag<__m256d, double>)\n{\n return AVX::convert(load16(mem, f));\n}\n\n// float {{{2\ntemplate \nVc_INTRINSIC __m256 load(const double *mem, Flags f, LoadTag<__m256, float>)\n{\n return AVX::concat(_mm256_cvtpd_ps(load32(&mem[0], f)),\n _mm256_cvtpd_ps(load32(&mem[4], f)));\n}\ntemplate \nVc_INTRINSIC __m256 load(const uint *mem, Flags f, LoadTag<__m256, float>)\n{\n const auto v = load32(mem, f);\n return _mm256_blendv_ps(\n _mm256_cvtepi32_ps(v),\n _mm256_add_ps(_mm256_cvtepi32_ps(AVX::sub_epi32(v, AVX::set2power31_epu32())),\n AVX::set2power31_ps()),\n _mm256_castsi256_ps(AVX::cmplt_epi32(v, _mm256_setzero_si256())));\n}\ntemplate \nVc_INTRINSIC __m256 load(const int *mem, Flags f, LoadTag<__m256, float>)\n{\n return AVX::convert(load32(mem, f));\n}\ntemplate ::value>>\nVc_INTRINSIC __m256 load(const T *mem, Flags f, LoadTag<__m256, float>)\n{\n return _mm256_cvtepi32_ps(load<__m256i, int>(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256 load(const ushort *mem, Flags f, LoadTag<__m256, float>)\n{\n return AVX::convert(load16(mem, f));\n}\ntemplate \nVc_INTRINSIC __m256 load(const short *mem, Flags f, LoadTag<__m256, float>)\n{\n return AVX::convert(load16(mem, f));\n}\n/*\ntemplate struct LoadHelper {\n static __m256 load(const unsigned char *mem, Flags)\n {\n return _mm256_cvtepi32_ps(\n cvtepu8_epi32(_mm_loadl_epi64(reinterpret_cast(mem))));\n }\n};\ntemplate struct LoadHelper {\n static __m256 load(const signed char *mem, Flags)\n {\n return _mm256_cvtepi32_ps(\n cvtepi8_epi32(_mm_loadl_epi64(reinterpret_cast(mem))));\n }\n};\n*/\n\n// shifted{{{1\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 32 && amount >= 16), T> shifted(T k)\n{\n return AVX::avx_cast(AVX::zeroExtend(\n _mm_srli_si128(AVX::hi128(AVX::avx_cast<__m256i>(k)), amount - 16)));\n}\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 32 && amount > 0 && amount < 16), T>\nshifted(T k)\n{\n return AVX::avx_cast(\n AVX::alignr(Mem::permute128(AVX::avx_cast<__m256i>(k)),\n AVX::avx_cast<__m256i>(k)));\n}\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 32 && amount <= -16), T> shifted(T k)\n{\n return AVX::avx_cast(Mem::permute128(AVX::avx_cast<__m256i>(\n _mm_slli_si128(AVX::lo128(AVX::avx_cast<__m256i>(k)), -16 - amount))));\n}\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(sizeof(T) == 32 && amount > -16 && amount < 0), T>\nshifted(T k)\n{\n return AVX::avx_cast(\n AVX::alignr<16 + amount>(AVX::avx_cast<__m256i>(k),\n Mem::permute128(AVX::avx_cast<__m256i>(k))));\n}\n// mask_cast{{{1\ntemplate Vc_INTRINSIC Vc_CONST R mask_cast(__m256i k)\n{\n static_assert(From == To, \"Incorrect mask cast.\");\n static_assert(std::is_same::value, \"Incorrect mask cast.\");\n return AVX::avx_cast<__m256>(k);\n}\n\n// 4 -> 4\ntemplate <> Vc_INTRINSIC Vc_CONST __m128 mask_cast<4, 4, __m128>(__m256i k)\n{\n return AVX::avx_cast<__m128>(_mm_packs_epi32(AVX::lo128(k), AVX::hi128(k)));\n}\n\ntemplate <> Vc_INTRINSIC Vc_CONST __m256 mask_cast<4, 4, __m256>(__m128i k)\n{\n const auto kk = _mm_castsi128_ps(k);\n return AVX::concat(_mm_unpacklo_ps(kk, kk), _mm_unpackhi_ps(kk, kk));\n}\n\n// 4 -> 8\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<4, 8, __m256>(__m256i k)\n{\n // aabb ccdd -> abcd 0000\n return AVX::avx_cast<__m256>(AVX::concat(_mm_packs_epi32(AVX::lo128(k), AVX::hi128(k)),\n _mm_setzero_si128()));\n}\n\ntemplate<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<4, 8, __m128>(__m256i k)\n{\n // aaaa bbbb cccc dddd -> abcd 0000\n return AVX::avx_cast<__m128>(_mm_packs_epi16(_mm_packs_epi32(AVX::lo128(k), AVX::hi128(k)), _mm_setzero_si128()));\n}\n\ntemplate <> Vc_INTRINSIC Vc_CONST __m256 mask_cast<4, 8, __m256>(__m128i k)\n{\n return AVX::zeroExtend(AVX::avx_cast<__m128>(k));\n}\n\n// 4 -> 16\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<4, 16, __m256>(__m256i k)\n{\n // aaaa bbbb cccc dddd -> abcd 0000 0000 0000\n return AVX::zeroExtend(mask_cast<4, 8, __m128>(k));\n}\n\n// 8 -> 4\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<8, 4, __m256>(__m256i k)\n{\n // aabb ccdd eeff gghh -> aaaa bbbb cccc dddd\n const auto lo = AVX::lo128(AVX::avx_cast<__m256>(k));\n return AVX::concat(_mm_unpacklo_ps(lo, lo),\n _mm_unpackhi_ps(lo, lo));\n}\n\ntemplate<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<8, 4, __m128>(__m256i k)\n{\n return AVX::avx_cast<__m128>(AVX::lo128(k));\n}\n\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<8, 4, __m256>(__m128i k)\n{\n // abcd efgh -> aaaa bbbb cccc dddd\n const auto tmp = _mm_unpacklo_epi16(k, k); // aa bb cc dd\n return AVX::avx_cast<__m256>(AVX::concat(_mm_unpacklo_epi32(tmp, tmp), // aaaa bbbb\n _mm_unpackhi_epi32(tmp, tmp))); // cccc dddd\n}\n\n// 8 -> 8\ntemplate<> Vc_INTRINSIC Vc_CONST __m128 mask_cast<8, 8, __m128>(__m256i k)\n{\n // aabb ccdd eeff gghh -> abcd efgh\n return AVX::avx_cast<__m128>(_mm_packs_epi16(AVX::lo128(k), AVX::hi128(k)));\n}\n\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<8, 8, __m256>(__m128i k)\n{\n return AVX::avx_cast<__m256>(AVX::concat(_mm_unpacklo_epi16(k, k),\n _mm_unpackhi_epi16(k, k)));\n}\n\n// 8 -> 16\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<8, 16, __m256>(__m256i k)\n{\n // aabb ccdd eeff gghh -> abcd efgh 0000 0000\n return AVX::zeroExtend(mask_cast<8, 8, __m128>(k));\n}\n\n// 16 -> 8\n#ifdef Vc_IMPL_AVX2\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<16, 8, __m256>(__m256i k)\n{\n // abcd efgh ijkl mnop -> aabb ccdd eeff gghh\n const auto flipped = Mem::permute4x64(k);\n return _mm256_castsi256_ps(AVX::unpacklo_epi16(flipped, flipped));\n}\n#endif\n\n// 16 -> 4\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 mask_cast<16, 4, __m256>(__m256i k)\n{\n // abcd efgh ijkl mnop -> aaaa bbbb cccc dddd\n const auto tmp = _mm_unpacklo_epi16(AVX::lo128(k), AVX::lo128(k)); // aabb ccdd\n return _mm256_castsi256_ps(AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)));\n}\n\n// allone{{{1\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 allone<__m256 >() { return AVX::setallone_ps(); }\ntemplate<> Vc_INTRINSIC Vc_CONST __m256i allone<__m256i>() { return AVX::setallone_si256(); }\ntemplate<> Vc_INTRINSIC Vc_CONST __m256d allone<__m256d>() { return AVX::setallone_pd(); }\n\n// zero{{{1\ntemplate<> Vc_INTRINSIC Vc_CONST __m256 zero<__m256 >() { return _mm256_setzero_ps(); }\ntemplate<> Vc_INTRINSIC Vc_CONST __m256i zero<__m256i>() { return _mm256_setzero_si256(); }\ntemplate<> Vc_INTRINSIC Vc_CONST __m256d zero<__m256d>() { return _mm256_setzero_pd(); }\n\n// one{{{1\nVc_INTRINSIC Vc_CONST __m256 one( float) { return AVX::setone_ps (); }\nVc_INTRINSIC Vc_CONST __m256d one(double) { return AVX::setone_pd (); }\nVc_INTRINSIC Vc_CONST __m256i one( int) { return AVX::setone_epi32(); }\nVc_INTRINSIC Vc_CONST __m256i one( uint) { return AVX::setone_epu32(); }\nVc_INTRINSIC Vc_CONST __m256i one( short) { return AVX::setone_epi16(); }\nVc_INTRINSIC Vc_CONST __m256i one(ushort) { return AVX::setone_epu16(); }\nVc_INTRINSIC Vc_CONST __m256i one( schar) { return AVX::setone_epi8 (); }\nVc_INTRINSIC Vc_CONST __m256i one( uchar) { return AVX::setone_epu8 (); }\n\n// negate{{{1\nVc_ALWAYS_INLINE Vc_CONST __m256 negate(__m256 v, std::integral_constant)\n{\n return _mm256_xor_ps(v, AVX::setsignmask_ps());\n}\nVc_ALWAYS_INLINE Vc_CONST __m256d negate(__m256d v, std::integral_constant)\n{\n return _mm256_xor_pd(v, AVX::setsignmask_pd());\n}\nVc_ALWAYS_INLINE Vc_CONST __m256i negate(__m256i v, std::integral_constant)\n{\n return AVX::sign_epi32(v, Detail::allone<__m256i>());\n}\nVc_ALWAYS_INLINE Vc_CONST __m256i negate(__m256i v, std::integral_constant)\n{\n return AVX::sign_epi16(v, Detail::allone<__m256i>());\n}\n\n// xor_{{{1\nVc_INTRINSIC __m256 xor_(__m256 a, __m256 b) { return _mm256_xor_ps(a, b); }\nVc_INTRINSIC __m256d xor_(__m256d a, __m256d b) { return _mm256_xor_pd(a, b); }\nVc_INTRINSIC __m256i xor_(__m256i a, __m256i b)\n{\n#ifdef Vc_IMPL_AVX2\n return _mm256_xor_si256(a, b);\n#else\n return _mm256_castps_si256(\n _mm256_xor_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));\n#endif\n}\n\n// or_{{{1\nVc_INTRINSIC __m256 or_(__m256 a, __m256 b) { return _mm256_or_ps(a, b); }\nVc_INTRINSIC __m256d or_(__m256d a, __m256d b) { return _mm256_or_pd(a, b); }\nVc_INTRINSIC __m256i or_(__m256i a, __m256i b)\n{\n#ifdef Vc_IMPL_AVX2\n return _mm256_or_si256(a, b);\n#else\n return _mm256_castps_si256(\n _mm256_or_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));\n#endif\n}\n\n// and_{{{1\nVc_INTRINSIC __m256 and_(__m256 a, __m256 b) { return _mm256_and_ps(a, b); }\nVc_INTRINSIC __m256d and_(__m256d a, __m256d b) { return _mm256_and_pd(a, b); }\nVc_INTRINSIC __m256i and_(__m256i a, __m256i b) {\n#ifdef Vc_IMPL_AVX2\n return _mm256_and_si256(a, b);\n#else\n return _mm256_castps_si256(\n _mm256_and_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));\n#endif\n}\n\n// andnot_{{{1\nVc_INTRINSIC __m256 andnot_(__m256 a, __m256 b) { return _mm256_andnot_ps(a, b); }\nVc_INTRINSIC __m256d andnot_(__m256d a, __m256d b) { return _mm256_andnot_pd(a, b); }\nVc_INTRINSIC __m256i andnot_(__m256i a, __m256i b)\n{\n#ifdef Vc_IMPL_AVX2\n return _mm256_andnot_si256(a, b);\n#else\n return _mm256_castps_si256(\n _mm256_andnot_ps(_mm256_castsi256_ps(a), _mm256_castsi256_ps(b)));\n#endif\n}\n\n// not_{{{1\nVc_INTRINSIC __m256 not_(__m256 a) { return andnot_(a, allone<__m256 >()); }\nVc_INTRINSIC __m256d not_(__m256d a) { return andnot_(a, allone<__m256d>()); }\nVc_INTRINSIC __m256i not_(__m256i a) { return andnot_(a, allone<__m256i>()); }\n\n// blend{{{1\nVc_INTRINSIC __m256 blend(__m256 a, __m256 b, __m256 c) { return _mm256_blendv_ps(a, b, c); }\nVc_INTRINSIC __m256d blend(__m256d a, __m256d b, __m256d c) { return _mm256_blendv_pd(a, b, c); }\nVc_INTRINSIC __m256i blend(__m256i a, __m256i b, __m256i c) { return AVX::blendv_epi8(a, b, c); }\n\n// abs{{{1\nVc_INTRINSIC __m256 abs(__m256 a, float) { return and_(a, AVX::setabsmask_ps()); }\nVc_INTRINSIC __m256d abs(__m256d a, double) { return and_(a, AVX::setabsmask_pd()); }\nVc_INTRINSIC __m256i abs(__m256i a, int) { return AVX::abs_epi32(a); }\nVc_INTRINSIC __m256i abs(__m256i a, uint) { return a; }\nVc_INTRINSIC __m256i abs(__m256i a, short) { return AVX::abs_epi16(a); }\nVc_INTRINSIC __m256i abs(__m256i a, ushort) { return a; }\nVc_INTRINSIC __m256i abs(__m256i a, schar) { return AVX::abs_epi8 (a); }\nVc_INTRINSIC __m256i abs(__m256i a, uchar) { return a; }\n\n// add{{{1\nVc_INTRINSIC __m256 add(__m256 a, __m256 b, float) { return _mm256_add_ps(a, b); }\nVc_INTRINSIC __m256d add(__m256d a, __m256d b, double) { return _mm256_add_pd(a, b); }\nVc_INTRINSIC __m256i add(__m256i a, __m256i b, int) { return AVX::add_epi32(a, b); }\nVc_INTRINSIC __m256i add(__m256i a, __m256i b, uint) { return AVX::add_epi32(a, b); }\nVc_INTRINSIC __m256i add(__m256i a, __m256i b, short) { return AVX::add_epi16(a, b); }\nVc_INTRINSIC __m256i add(__m256i a, __m256i b, ushort) { return AVX::add_epi16(a, b); }\n\n// sub{{{1\nVc_INTRINSIC __m256 sub(__m256 a, __m256 b, float) { return _mm256_sub_ps(a, b); }\nVc_INTRINSIC __m256d sub(__m256d a, __m256d b, double) { return _mm256_sub_pd(a, b); }\nVc_INTRINSIC __m256i sub(__m256i a, __m256i b, int) { return AVX::sub_epi32(a, b); }\nVc_INTRINSIC __m256i sub(__m256i a, __m256i b, uint) { return AVX::sub_epi32(a, b); }\nVc_INTRINSIC __m256i sub(__m256i a, __m256i b, short) { return AVX::sub_epi16(a, b); }\nVc_INTRINSIC __m256i sub(__m256i a, __m256i b, ushort) { return AVX::sub_epi16(a, b); }\n\n// mul{{{1\nVc_INTRINSIC __m256 mul(__m256 a, __m256 b, float) { return _mm256_mul_ps(a, b); }\nVc_INTRINSIC __m256d mul(__m256d a, __m256d b, double) { return _mm256_mul_pd(a, b); }\nVc_INTRINSIC __m256i mul(__m256i a, __m256i b, int) { return AVX::mullo_epi32(a, b); }\nVc_INTRINSIC __m256i mul(__m256i a, __m256i b, uint) { return AVX::mullo_epi32(a, b); }\nVc_INTRINSIC __m256i mul(__m256i a, __m256i b, short) { return AVX::mullo_epi16(a, b); }\nVc_INTRINSIC __m256i mul(__m256i a, __m256i b, ushort) { return AVX::mullo_epi16(a, b); }\n\n// mul{{{1\nVc_INTRINSIC __m256 div(__m256 a, __m256 b, float) { return _mm256_div_ps(a, b); }\nVc_INTRINSIC __m256d div(__m256d a, __m256d b, double) { return _mm256_div_pd(a, b); }\nVc_INTRINSIC __m256i div(__m256i a, __m256i b, int) {\n using namespace AVX;\n const __m256d lo1 = _mm256_cvtepi32_pd(lo128(a));\n const __m256d lo2 = _mm256_cvtepi32_pd(lo128(b));\n const __m256d hi1 = _mm256_cvtepi32_pd(hi128(a));\n const __m256d hi2 = _mm256_cvtepi32_pd(hi128(b));\n return concat(_mm256_cvttpd_epi32(_mm256_div_pd(lo1, lo2)),\n _mm256_cvttpd_epi32(_mm256_div_pd(hi1, hi2)));\n}\nVc_INTRINSIC __m256i div(__m256i a, __m256i b, uint) {\n // SSE/AVX only has signed int conversion to doubles. Therefore we first adjust the input before\n // conversion and take the adjustment back after the conversion.\n // It could be argued that for b this is not really important because division by a b >= 2^31 is\n // useless. But for full correctness it cannot be ignored.\n using namespace AVX;\n const __m256i aa = add_epi32(a, set1_epi32(-2147483648));\n const __m256i bb = add_epi32(b, set1_epi32(-2147483648));\n const __m256d loa = _mm256_add_pd(_mm256_cvtepi32_pd(lo128(aa)), set1_pd(2147483648.));\n const __m256d hia = _mm256_add_pd(_mm256_cvtepi32_pd(hi128(aa)), set1_pd(2147483648.));\n const __m256d lob = _mm256_add_pd(_mm256_cvtepi32_pd(lo128(bb)), set1_pd(2147483648.));\n const __m256d hib = _mm256_add_pd(_mm256_cvtepi32_pd(hi128(bb)), set1_pd(2147483648.));\n // there is one remaining problem: a >= 2^31 and b == 1\n // in that case the return value would be 2^31\n return avx_cast<__m256i>(_mm256_blendv_ps(\n avx_cast<__m256>(concat(_mm256_cvttpd_epi32(_mm256_div_pd(loa, lob)),\n _mm256_cvttpd_epi32(_mm256_div_pd(hia, hib)))),\n avx_cast<__m256>(a),\n avx_cast<__m256>(cmpeq_epi32(b, setone_epi32()))));\n}\nVc_INTRINSIC __m256i div(__m256i a, __m256i b, short) {\n using namespace AVX;\n const __m256 lo =\n _mm256_div_ps(convert(lo128(a)), convert(lo128(b)));\n const __m256 hi =\n _mm256_div_ps(convert(hi128(a)), convert(hi128(b)));\n return concat(convert(lo), convert(hi));\n}\n\n// horizontal add{{{1\ntemplate Vc_INTRINSIC T add(Common::IntrinsicType a, T)\n{\n return {add(add(AVX::lo128(a), AVX::hi128(a), T()), T())};\n}\n\n// horizontal mul{{{1\ntemplate Vc_INTRINSIC T mul(Common::IntrinsicType a, T)\n{\n return {mul(mul(AVX::lo128(a), AVX::hi128(a), T()), T())};\n}\n\n// horizontal min{{{1\ntemplate Vc_INTRINSIC T min(Common::IntrinsicType a, T)\n{\n return {min(min(AVX::lo128(a), AVX::hi128(a), T()), T())};\n}\n\n// horizontal max{{{1\ntemplate Vc_INTRINSIC T max(Common::IntrinsicType a, T)\n{\n return {max(max(AVX::lo128(a), AVX::hi128(a), T()), T())};\n}\n// cmpeq{{{1\nVc_INTRINSIC __m256 cmpeq(__m256 a, __m256 b, float) { return AvxIntrinsics::cmpeq_ps(a, b); }\nVc_INTRINSIC __m256d cmpeq(__m256d a, __m256d b, double) { return AvxIntrinsics::cmpeq_pd(a, b); }\nVc_INTRINSIC __m256i cmpeq(__m256i a, __m256i b, int) { return AvxIntrinsics::cmpeq_epi32(a, b); }\nVc_INTRINSIC __m256i cmpeq(__m256i a, __m256i b, uint) { return AvxIntrinsics::cmpeq_epi32(a, b); }\nVc_INTRINSIC __m256i cmpeq(__m256i a, __m256i b, short) { return AvxIntrinsics::cmpeq_epi16(a, b); }\nVc_INTRINSIC __m256i cmpeq(__m256i a, __m256i b, ushort) { return AvxIntrinsics::cmpeq_epi16(a, b); }\n\n// cmpneq{{{1\nVc_INTRINSIC __m256 cmpneq(__m256 a, __m256 b, float) { return AvxIntrinsics::cmpneq_ps(a, b); }\nVc_INTRINSIC __m256d cmpneq(__m256d a, __m256d b, double) { return AvxIntrinsics::cmpneq_pd(a, b); }\nVc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b, int) { return not_(AvxIntrinsics::cmpeq_epi32(a, b)); }\nVc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b, uint) { return not_(AvxIntrinsics::cmpeq_epi32(a, b)); }\nVc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b, short) { return not_(AvxIntrinsics::cmpeq_epi16(a, b)); }\nVc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b, ushort) { return not_(AvxIntrinsics::cmpeq_epi16(a, b)); }\nVc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b, schar) { return not_(AvxIntrinsics::cmpeq_epi8 (a, b)); }\nVc_INTRINSIC __m256i cmpneq(__m256i a, __m256i b, uchar) { return not_(AvxIntrinsics::cmpeq_epi8 (a, b)); }\n\n// cmpgt{{{1\nVc_INTRINSIC __m256 cmpgt(__m256 a, __m256 b, float) { return AVX::cmpgt_ps(a, b); }\nVc_INTRINSIC __m256d cmpgt(__m256d a, __m256d b, double) { return AVX::cmpgt_pd(a, b); }\nVc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b, int) { return AVX::cmpgt_epi32(a, b); }\nVc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b, uint) { return AVX::cmpgt_epu32(a, b); }\nVc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b, short) { return AVX::cmpgt_epi16(a, b); }\nVc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b, ushort) { return AVX::cmpgt_epu16(a, b); }\nVc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b, schar) { return AVX::cmpgt_epi8 (a, b); }\nVc_INTRINSIC __m256i cmpgt(__m256i a, __m256i b, uchar) { return AVX::cmpgt_epu8 (a, b); }\n\n// cmpge{{{1\nVc_INTRINSIC __m256 cmpge(__m256 a, __m256 b, float) { return AVX::cmpge_ps(a, b); }\nVc_INTRINSIC __m256d cmpge(__m256d a, __m256d b, double) { return AVX::cmpge_pd(a, b); }\nVc_INTRINSIC __m256i cmpge(__m256i a, __m256i b, int) { return not_(AVX::cmpgt_epi32(b, a)); }\nVc_INTRINSIC __m256i cmpge(__m256i a, __m256i b, uint) { return not_(AVX::cmpgt_epu32(b, a)); }\nVc_INTRINSIC __m256i cmpge(__m256i a, __m256i b, short) { return not_(AVX::cmpgt_epi16(b, a)); }\nVc_INTRINSIC __m256i cmpge(__m256i a, __m256i b, ushort) { return not_(AVX::cmpgt_epu16(b, a)); }\nVc_INTRINSIC __m256i cmpge(__m256i a, __m256i b, schar) { return not_(AVX::cmpgt_epi8 (b, a)); }\nVc_INTRINSIC __m256i cmpge(__m256i a, __m256i b, uchar) { return not_(AVX::cmpgt_epu8 (b, a)); }\n\n// cmple{{{1\nVc_INTRINSIC __m256 cmple(__m256 a, __m256 b, float) { return AVX::cmple_ps(a, b); }\nVc_INTRINSIC __m256d cmple(__m256d a, __m256d b, double) { return AVX::cmple_pd(a, b); }\nVc_INTRINSIC __m256i cmple(__m256i a, __m256i b, int) { return not_(AVX::cmpgt_epi32(a, b)); }\nVc_INTRINSIC __m256i cmple(__m256i a, __m256i b, uint) { return not_(AVX::cmpgt_epu32(a, b)); }\nVc_INTRINSIC __m256i cmple(__m256i a, __m256i b, short) { return not_(AVX::cmpgt_epi16(a, b)); }\nVc_INTRINSIC __m256i cmple(__m256i a, __m256i b, ushort) { return not_(AVX::cmpgt_epu16(a, b)); }\nVc_INTRINSIC __m256i cmple(__m256i a, __m256i b, schar) { return not_(AVX::cmpgt_epi8 (a, b)); }\nVc_INTRINSIC __m256i cmple(__m256i a, __m256i b, uchar) { return not_(AVX::cmpgt_epu8 (a, b)); }\n\n// cmplt{{{1\nVc_INTRINSIC __m256 cmplt(__m256 a, __m256 b, float) { return AVX::cmplt_ps(a, b); }\nVc_INTRINSIC __m256d cmplt(__m256d a, __m256d b, double) { return AVX::cmplt_pd(a, b); }\nVc_INTRINSIC __m256i cmplt(__m256i a, __m256i b, int) { return AVX::cmpgt_epi32(b, a); }\nVc_INTRINSIC __m256i cmplt(__m256i a, __m256i b, uint) { return AVX::cmpgt_epu32(b, a); }\nVc_INTRINSIC __m256i cmplt(__m256i a, __m256i b, short) { return AVX::cmpgt_epi16(b, a); }\nVc_INTRINSIC __m256i cmplt(__m256i a, __m256i b, ushort) { return AVX::cmpgt_epu16(b, a); }\nVc_INTRINSIC __m256i cmplt(__m256i a, __m256i b, schar) { return AVX::cmpgt_epi8 (b, a); }\nVc_INTRINSIC __m256i cmplt(__m256i a, __m256i b, uchar) { return AVX::cmpgt_epu8 (b, a); }\n\n// fma{{{1\nVc_INTRINSIC __m256 fma(__m256 a, __m256 b, __m256 c, float) {\n#ifdef Vc_IMPL_FMA4\n return _mm256_macc_ps(a, b, c);\n#elif defined Vc_IMPL_FMA\n return _mm256_fmadd_ps(a, b, c);\n#else\n using namespace AVX;\n __m256d v1_0 = _mm256_cvtps_pd(lo128(a));\n __m256d v1_1 = _mm256_cvtps_pd(hi128(a));\n __m256d v2_0 = _mm256_cvtps_pd(lo128(b));\n __m256d v2_1 = _mm256_cvtps_pd(hi128(b));\n __m256d v3_0 = _mm256_cvtps_pd(lo128(c));\n __m256d v3_1 = _mm256_cvtps_pd(hi128(c));\n return concat(_mm256_cvtpd_ps(_mm256_add_pd(_mm256_mul_pd(v1_0, v2_0), v3_0)),\n _mm256_cvtpd_ps(_mm256_add_pd(_mm256_mul_pd(v1_1, v2_1), v3_1)));\n#endif\n}\nVc_INTRINSIC __m256d fma(__m256d a, __m256d b, __m256d c, double)\n{\n#ifdef Vc_IMPL_FMA4\n return _mm256_macc_pd(a, b, c);\n#elif defined Vc_IMPL_FMA\n return _mm256_fmadd_pd(a, b, c);\n#else\n using namespace AVX;\n __m256d h1 = and_(a, _mm256_broadcast_sd(reinterpret_cast(\n &c_general::highMaskDouble)));\n __m256d h2 = and_(b, _mm256_broadcast_sd(reinterpret_cast(\n &c_general::highMaskDouble)));\n const __m256d l1 = _mm256_sub_pd(a, h1);\n const __m256d l2 = _mm256_sub_pd(b, h2);\n const __m256d ll = mul(l1, l2, double());\n const __m256d lh = add(mul(l1, h2, double()), mul(h1, l2, double()), double());\n const __m256d hh = mul(h1, h2, double());\n // ll < lh < hh for all entries is certain\n const __m256d lh_lt_v3 = cmplt(abs(lh, double()), abs(c, double()), double()); // |lh| < |c|\n const __m256d x = _mm256_blendv_pd(c, lh, lh_lt_v3);\n const __m256d y = _mm256_blendv_pd(lh, c, lh_lt_v3);\n return add(add(ll, x, double()), add(y, hh, double()), double());\n#endif\n}\ntemplate Vc_INTRINSIC __m256i fma(__m256i a, __m256i b, __m256i c, T)\n{\n return add(mul(a, b, T()), c, T());\n}\n\n// shiftRight{{{1\ntemplate Vc_INTRINSIC __m256i shiftRight(__m256i a, int) { return AVX::srai_epi32(a); }\ntemplate Vc_INTRINSIC __m256i shiftRight(__m256i a, uint) { return AVX::srli_epi32(a); }\ntemplate Vc_INTRINSIC __m256i shiftRight(__m256i a, short) { return AVX::srai_epi16(a); }\ntemplate Vc_INTRINSIC __m256i shiftRight(__m256i a, ushort) { return AVX::srli_epi16(a); }\n//template Vc_INTRINSIC __m256i shiftRight(__m256i a, schar) { return AVX::srai_epi8 (a); }\n//template Vc_INTRINSIC __m256i shiftRight(__m256i a, uchar) { return AVX::srli_epi8 (a); }\n\nVc_INTRINSIC __m256i shiftRight(__m256i a, int shift, int) { return AVX::sra_epi32(a, _mm_cvtsi32_si128(shift)); }\nVc_INTRINSIC __m256i shiftRight(__m256i a, int shift, uint) { return AVX::srl_epi32(a, _mm_cvtsi32_si128(shift)); }\nVc_INTRINSIC __m256i shiftRight(__m256i a, int shift, short) { return AVX::sra_epi16(a, _mm_cvtsi32_si128(shift)); }\nVc_INTRINSIC __m256i shiftRight(__m256i a, int shift, ushort) { return AVX::srl_epi16(a, _mm_cvtsi32_si128(shift)); }\n//Vc_INTRINSIC __m256i shiftRight(__m256i a, int shift, schar) { return AVX::sra_epi8 (a, _mm_cvtsi32_si128(shift)); }\n//Vc_INTRINSIC __m256i shiftRight(__m256i a, int shift, uchar) { return AVX::srl_epi8 (a, _mm_cvtsi32_si128(shift)); }\n\n// shiftLeft{{{1\ntemplate Vc_INTRINSIC __m256i shiftLeft(__m256i a, int) { return AVX::slli_epi32(a); }\ntemplate Vc_INTRINSIC __m256i shiftLeft(__m256i a, uint) { return AVX::slli_epi32(a); }\ntemplate Vc_INTRINSIC __m256i shiftLeft(__m256i a, short) { return AVX::slli_epi16(a); }\ntemplate Vc_INTRINSIC __m256i shiftLeft(__m256i a, ushort) { return AVX::slli_epi16(a); }\n//template Vc_INTRINSIC __m256i shiftLeft(__m256i a, schar) { return AVX::slli_epi8 (a); }\n//template Vc_INTRINSIC __m256i shiftLeft(__m256i a, uchar) { return AVX::slli_epi8 (a); }\n\nVc_INTRINSIC __m256i shiftLeft(__m256i a, int shift, int) { return AVX::sll_epi32(a, _mm_cvtsi32_si128(shift)); }\nVc_INTRINSIC __m256i shiftLeft(__m256i a, int shift, uint) { return AVX::sll_epi32(a, _mm_cvtsi32_si128(shift)); }\nVc_INTRINSIC __m256i shiftLeft(__m256i a, int shift, short) { return AVX::sll_epi16(a, _mm_cvtsi32_si128(shift)); }\nVc_INTRINSIC __m256i shiftLeft(__m256i a, int shift, ushort) { return AVX::sll_epi16(a, _mm_cvtsi32_si128(shift)); }\n//Vc_INTRINSIC __m256i shiftLeft(__m256i a, int shift, schar) { return AVX::sll_epi8 (a, _mm_cvtsi32_si128(shift)); }\n//Vc_INTRINSIC __m256i shiftLeft(__m256i a, int shift, uchar) { return AVX::sll_epi8 (a, _mm_cvtsi32_si128(shift)); }\n\n// zeroExtendIfNeeded{{{1\nVc_INTRINSIC __m256 zeroExtendIfNeeded(__m256 x) { return x; }\nVc_INTRINSIC __m256d zeroExtendIfNeeded(__m256d x) { return x; }\nVc_INTRINSIC __m256i zeroExtendIfNeeded(__m256i x) { return x; }\nVc_INTRINSIC __m256 zeroExtendIfNeeded(__m128 x) { return AVX::zeroExtend(x); }\nVc_INTRINSIC __m256d zeroExtendIfNeeded(__m128d x) { return AVX::zeroExtend(x); }\nVc_INTRINSIC __m256i zeroExtendIfNeeded(__m128i x) { return AVX::zeroExtend(x); }\n\n// broadcast{{{1\nVc_INTRINSIC __m256 avx_broadcast( float x) { return _mm256_set1_ps(x); }\nVc_INTRINSIC __m256d avx_broadcast(double x) { return _mm256_set1_pd(x); }\nVc_INTRINSIC __m256i avx_broadcast( int x) { return _mm256_set1_epi32(x); }\nVc_INTRINSIC __m256i avx_broadcast( uint x) { return _mm256_set1_epi32(x); }\nVc_INTRINSIC __m256i avx_broadcast( short x) { return _mm256_set1_epi16(x); }\nVc_INTRINSIC __m256i avx_broadcast(ushort x) { return _mm256_set1_epi16(x); }\nVc_INTRINSIC __m256i avx_broadcast( char x) { return _mm256_set1_epi8(x); }\nVc_INTRINSIC __m256i avx_broadcast( schar x) { return _mm256_set1_epi8(x); }\nVc_INTRINSIC __m256i avx_broadcast( uchar x) { return _mm256_set1_epi8(x); }\n\n// sorted{{{1\ntemplate = AVXImpl && Impl <= AVX2Impl)>>\nVc_CONST_L AVX2::Vector Vc_VDECL sorted(AVX2::Vector x) Vc_CONST_R;\ntemplate Vc_INTRINSIC Vc_CONST AVX2::Vector sorted(AVX2::Vector x)\n{\n return sorted(x);\n}\n\n// shifted{{{1\ntemplate \nstatic Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 32), V> shifted(V v, int amount)\n{\n using namespace AVX;\n constexpr int S = sizeof(T);\n switch (amount) {\n case 0: return v;\n case 1: return shifted( 1 * S)>(v);\n case 2: return shifted( 2 * S)>(v);\n case 3: return shifted( 3 * S)>(v);\n case -1: return shifted(-1 * S)>(v);\n case -2: return shifted(-2 * S)>(v);\n case -3: return shifted(-3 * S)>(v);\n }\n if (sizeof(T) <= 4) {\n switch (amount) {\n case 4: return shifted( 4 * S)>(v);\n case 5: return shifted( 5 * S)>(v);\n case 6: return shifted( 6 * S)>(v);\n case 7: return shifted( 7 * S)>(v);\n case -4: return shifted(-4 * S)>(v);\n case -5: return shifted(-5 * S)>(v);\n case -6: return shifted(-6 * S)>(v);\n case -7: return shifted(-7 * S)>(v);\n }\n if (sizeof(T) <= 2) {\n switch (amount) {\n case 8: return shifted( 8 * S)>(v);\n case 9: return shifted( 9 * S)>(v);\n case 10: return shifted( 10 * S)>(v);\n case 11: return shifted( 11 * S)>(v);\n case 12: return shifted( 12 * S)>(v);\n case 13: return shifted( 13 * S)>(v);\n case 14: return shifted( 14 * S)>(v);\n case 15: return shifted( 15 * S)>(v);\n case -8: return shifted(- 8 * S)>(v);\n case -9: return shifted(- 9 * S)>(v);\n case -10: return shifted(-10 * S)>(v);\n case -11: return shifted(-11 * S)>(v);\n case -12: return shifted(-12 * S)>(v);\n case -13: return shifted(-13 * S)>(v);\n case -14: return shifted(-14 * S)>(v);\n case -15: return shifted(-15 * S)>(v);\n }\n if (sizeof(T) == 1) {\n switch (amount) {\n case 16: return shifted( 16)>(v);\n case 17: return shifted( 17)>(v);\n case 18: return shifted( 18)>(v);\n case 19: return shifted( 19)>(v);\n case 20: return shifted( 20)>(v);\n case 21: return shifted( 21)>(v);\n case 22: return shifted( 22)>(v);\n case 23: return shifted( 23)>(v);\n case 24: return shifted( 24)>(v);\n case 25: return shifted( 25)>(v);\n case 26: return shifted( 26)>(v);\n case 27: return shifted( 27)>(v);\n case 28: return shifted( 28)>(v);\n case 29: return shifted( 29)>(v);\n case 30: return shifted( 30)>(v);\n case 31: return shifted( 31)>(v);\n case -16: return shifted(-16)>(v);\n case -17: return shifted(-17)>(v);\n case -18: return shifted(-18)>(v);\n case -19: return shifted(-19)>(v);\n case -20: return shifted(-20)>(v);\n case -21: return shifted(-21)>(v);\n case -22: return shifted(-22)>(v);\n case -23: return shifted(-23)>(v);\n case -24: return shifted(-24)>(v);\n case -25: return shifted(-25)>(v);\n case -26: return shifted(-26)>(v);\n case -27: return shifted(-27)>(v);\n case -28: return shifted(-28)>(v);\n case -29: return shifted(-29)>(v);\n case -30: return shifted(-30)>(v);\n case -31: return shifted(-31)>(v);\n }\n }\n }\n }\n return avx_cast(_mm256_setzero_ps());\n}\n\ntemplate \nstatic Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 16), V> shifted(V v, int amount)\n{\n using namespace AVX;\n switch (amount) {\n case 0: return v;\n case 1: return avx_cast(_mm_srli_si128(avx_cast<__m128i>(v), sanitize(1 * sizeof(T))));\n case 2: return avx_cast(_mm_srli_si128(avx_cast<__m128i>(v), sanitize(2 * sizeof(T))));\n case 3: return avx_cast(_mm_srli_si128(avx_cast<__m128i>(v), sanitize(3 * sizeof(T))));\n case -1: return avx_cast(_mm_slli_si128(avx_cast<__m128i>(v), sanitize(1 * sizeof(T))));\n case -2: return avx_cast(_mm_slli_si128(avx_cast<__m128i>(v), sanitize(2 * sizeof(T))));\n case -3: return avx_cast(_mm_slli_si128(avx_cast<__m128i>(v), sanitize(3 * sizeof(T))));\n }\n if (sizeof(T) <= 2) {\n switch (amount) {\n case 4: return avx_cast(_mm_srli_si128(avx_cast<__m128i>(v), sanitize(4 * sizeof(T))));\n case 5: return avx_cast(_mm_srli_si128(avx_cast<__m128i>(v), sanitize(5 * sizeof(T))));\n case 6: return avx_cast(_mm_srli_si128(avx_cast<__m128i>(v), sanitize(6 * sizeof(T))));\n case 7: return avx_cast(_mm_srli_si128(avx_cast<__m128i>(v), sanitize(7 * sizeof(T))));\n case -4: return avx_cast(_mm_slli_si128(avx_cast<__m128i>(v), sanitize(4 * sizeof(T))));\n case -5: return avx_cast(_mm_slli_si128(avx_cast<__m128i>(v), sanitize(5 * sizeof(T))));\n case -6: return avx_cast(_mm_slli_si128(avx_cast<__m128i>(v), sanitize(6 * sizeof(T))));\n case -7: return avx_cast(_mm_slli_si128(avx_cast<__m128i>(v), sanitize(7 * sizeof(T))));\n }\n }\n return avx_cast(_mm_setzero_ps());\n}\n// rotated{{{1\ntemplate \nstatic Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 32 && N == 4), V> rotated(V v,\n int amount)\n{\n using namespace AVX;\n const __m128i vLo = avx_cast<__m128i>(lo128(v));\n const __m128i vHi = avx_cast<__m128i>(hi128(v));\n switch (static_cast(amount) % N) {\n case 0:\n return v;\n case 1:\n return avx_cast(concat(SSE::alignr_epi8(vHi, vLo),\n SSE::alignr_epi8(vLo, vHi)));\n case 2:\n return Mem::permute128(v);\n case 3:\n return avx_cast(concat(SSE::alignr_epi8(vLo, vHi),\n SSE::alignr_epi8(vHi, vLo)));\n }\n return avx_cast(_mm256_setzero_ps());\n}\n\ntemplate \nstatic Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 32 && N == 8), V> rotated(V v,\n int amount)\n{\n using namespace AVX;\n const __m128i vLo = avx_cast<__m128i>(lo128(v));\n const __m128i vHi = avx_cast<__m128i>(hi128(v));\n switch (static_cast(amount) % N) {\n case 0:\n return v;\n case 1:\n return avx_cast(concat(SSE::alignr_epi8<1 * sizeof(T)>(vHi, vLo),\n SSE::alignr_epi8<1 * sizeof(T)>(vLo, vHi)));\n case 2:\n return avx_cast(concat(SSE::alignr_epi8<2 * sizeof(T)>(vHi, vLo),\n SSE::alignr_epi8<2 * sizeof(T)>(vLo, vHi)));\n case 3:\n return avx_cast(concat(SSE::alignr_epi8<3 * sizeof(T)>(vHi, vLo),\n SSE::alignr_epi8<3 * sizeof(T)>(vLo, vHi)));\n case 4:\n return Mem::permute128(v);\n case 5:\n return avx_cast(concat(SSE::alignr_epi8<1 * sizeof(T)>(vLo, vHi),\n SSE::alignr_epi8<1 * sizeof(T)>(vHi, vLo)));\n case 6:\n return avx_cast(concat(SSE::alignr_epi8<2 * sizeof(T)>(vLo, vHi),\n SSE::alignr_epi8<2 * sizeof(T)>(vHi, vLo)));\n case 7:\n return avx_cast(concat(SSE::alignr_epi8<3 * sizeof(T)>(vLo, vHi),\n SSE::alignr_epi8<3 * sizeof(T)>(vHi, vLo)));\n }\n return avx_cast(_mm256_setzero_ps());\n}\n\n#ifdef Vc_IMPL_AVX2\ntemplate \nstatic Vc_INTRINSIC Vc_CONST enable_if<(sizeof(V) == 32 && N == 16), V> rotated(\n V v, int amount)\n{\n using namespace AVX;\n const __m128i vLo = avx_cast<__m128i>(lo128(v));\n const __m128i vHi = avx_cast<__m128i>(hi128(v));\n switch (static_cast(amount) % N) {\n case 0:\n return v;\n case 1:\n return avx_cast(concat(SSE::alignr_epi8<1 * sizeof(T)>(vHi, vLo),\n SSE::alignr_epi8<1 * sizeof(T)>(vLo, vHi)));\n case 2:\n return avx_cast(concat(SSE::alignr_epi8<2 * sizeof(T)>(vHi, vLo),\n SSE::alignr_epi8<2 * sizeof(T)>(vLo, vHi)));\n case 3:\n return avx_cast(concat(SSE::alignr_epi8<3 * sizeof(T)>(vHi, vLo),\n SSE::alignr_epi8<3 * sizeof(T)>(vLo, vHi)));\n case 4:\n return Mem::permute4x64(v);\n case 5:\n return avx_cast(concat(SSE::alignr_epi8<5 * sizeof(T)>(vHi, vLo),\n SSE::alignr_epi8<5 * sizeof(T)>(vLo, vHi)));\n case 6:\n return avx_cast(concat(SSE::alignr_epi8<6 * sizeof(T)>(vHi, vLo),\n SSE::alignr_epi8<6 * sizeof(T)>(vLo, vHi)));\n case 7:\n return avx_cast(concat(SSE::alignr_epi8<7 * sizeof(T)>(vHi, vLo),\n SSE::alignr_epi8<7 * sizeof(T)>(vLo, vHi)));\n case 8:\n return Mem::permute128(v);\n case 9:\n return avx_cast(concat(SSE::alignr_epi8<1 * sizeof(T)>(vLo, vHi),\n SSE::alignr_epi8<1 * sizeof(T)>(vHi, vLo)));\n case 10:\n return avx_cast(concat(SSE::alignr_epi8<2 * sizeof(T)>(vLo, vHi),\n SSE::alignr_epi8<2 * sizeof(T)>(vHi, vLo)));\n case 11:\n return avx_cast(concat(SSE::alignr_epi8<3 * sizeof(T)>(vLo, vHi),\n SSE::alignr_epi8<3 * sizeof(T)>(vHi, vLo)));\n case 12:\n return Mem::permute4x64(v);\n case 13:\n return avx_cast(concat(SSE::alignr_epi8<5 * sizeof(T)>(vLo, vHi),\n SSE::alignr_epi8<5 * sizeof(T)>(vHi, vLo)));\n case 14:\n return avx_cast(concat(SSE::alignr_epi8<6 * sizeof(T)>(vLo, vHi),\n SSE::alignr_epi8<6 * sizeof(T)>(vHi, vLo)));\n case 15:\n return avx_cast(concat(SSE::alignr_epi8<7 * sizeof(T)>(vLo, vHi),\n SSE::alignr_epi8<7 * sizeof(T)>(vHi, vLo)));\n }\n return avx_cast(_mm256_setzero_ps());\n}\n#endif // Vc_IMPL_AVX2\n\n// testc{{{1\nVc_INTRINSIC Vc_CONST int testc(__m128 a, __m128 b) { return _mm_testc_si128(_mm_castps_si128(a), _mm_castps_si128(b)); }\nVc_INTRINSIC Vc_CONST int testc(__m256 a, __m256 b) { return _mm256_testc_ps(a, b); }\nVc_INTRINSIC Vc_CONST int testc(__m256d a, __m256d b) { return _mm256_testc_pd(a, b); }\nVc_INTRINSIC Vc_CONST int testc(__m256i a, __m256i b) { return _mm256_testc_si256(a, b); }\n\n// testz{{{1\nVc_INTRINSIC Vc_CONST int testz(__m128 a, __m128 b) { return _mm_testz_si128(_mm_castps_si128(a), _mm_castps_si128(b)); }\nVc_INTRINSIC Vc_CONST int testz(__m256 a, __m256 b) { return _mm256_testz_ps(a, b); }\nVc_INTRINSIC Vc_CONST int testz(__m256d a, __m256d b) { return _mm256_testz_pd(a, b); }\nVc_INTRINSIC Vc_CONST int testz(__m256i a, __m256i b) { return _mm256_testz_si256(a, b); }\n\n// testnzc{{{1\nVc_INTRINSIC Vc_CONST int testnzc(__m128 a, __m128 b) { return _mm_testnzc_si128(_mm_castps_si128(a), _mm_castps_si128(b)); }\nVc_INTRINSIC Vc_CONST int testnzc(__m256 a, __m256 b) { return _mm256_testnzc_ps(a, b); }\nVc_INTRINSIC Vc_CONST int testnzc(__m256d a, __m256d b) { return _mm256_testnzc_pd(a, b); }\nVc_INTRINSIC Vc_CONST int testnzc(__m256i a, __m256i b) { return _mm256_testnzc_si256(a, b); }\n\n// movemask{{{1\nVc_INTRINSIC Vc_CONST int movemask(__m256i a) { return AVX::movemask_epi8(a); }\nVc_INTRINSIC Vc_CONST int movemask(__m128i a) { return _mm_movemask_epi8(a); }\nVc_INTRINSIC Vc_CONST int movemask(__m256d a) { return _mm256_movemask_pd(a); }\nVc_INTRINSIC Vc_CONST int movemask(__m128d a) { return _mm_movemask_pd(a); }\nVc_INTRINSIC Vc_CONST int movemask(__m256 a) { return _mm256_movemask_ps(a); }\nVc_INTRINSIC Vc_CONST int movemask(__m128 a) { return _mm_movemask_ps(a); }\n\n// mask_store{{{1\ntemplate \nVc_INTRINSIC void mask_store(__m256i k, bool *mem, Flags)\n{\n static_assert(\n N == 4 || N == 8 || N == 16,\n \"mask_store(__m256i, bool *) is only implemented for 4, 8, and 16 entries\");\n switch (N) {\n case 4:\n *aliasing_cast(mem) = (_mm_movemask_epi8(AVX::lo128(k)) |\n (_mm_movemask_epi8(AVX::hi128(k)) << 16)) &\n 0x01010101;\n break;\n case 8: {\n const auto k2 = _mm_srli_epi16(_mm_packs_epi16(AVX::lo128(k), AVX::hi128(k)), 15);\n const auto k3 = _mm_packs_epi16(k2, _mm_setzero_si128());\n#ifdef __x86_64__\n *aliasing_cast(mem) = _mm_cvtsi128_si64(k3);\n#else\n *aliasing_cast(mem) = _mm_cvtsi128_si32(k3);\n *aliasing_cast(mem + 4) = _mm_extract_epi32(k3, 1);\n#endif\n } break;\n case 16: {\n const auto bools = Detail::and_(_mm_set1_epi8(1),\n _mm_packs_epi16(AVX::lo128(k), AVX::hi128(k)));\n if (Flags::IsAligned) {\n _mm_store_si128(reinterpret_cast<__m128i *>(mem), bools);\n } else {\n _mm_storeu_si128(reinterpret_cast<__m128i *>(mem), bools);\n }\n } break;\n default:\n Vc_UNREACHABLE();\n }\n}\n\n// mask_load{{{1\ntemplate \nVc_INTRINSIC R mask_load(const bool *mem, Flags,\n enable_if::value> = nullarg)\n{\n static_assert(N == 4 || N == 8,\n \"mask_load<__m128>(const bool *) is only implemented for 4, 8 entries\");\n switch (N) {\n case 4: {\n __m128i k = _mm_cvtsi32_si128(*aliasing_cast(mem));\n k = _mm_unpacklo_epi8(k, k);\n k = _mm_unpacklo_epi16(k, k);\n k = _mm_cmpgt_epi32(k, _mm_setzero_si128());\n return AVX::avx_cast<__m128>(k);\n }\n case 8: {\n#ifdef __x86_64__\n __m128i k = _mm_cvtsi64_si128(*aliasing_cast(mem));\n#else\n __m128i k = _mm_castpd_si128(_mm_load_sd(aliasing_cast(mem)));\n#endif\n return AVX::avx_cast<__m128>(\n _mm_cmpgt_epi16(_mm_unpacklo_epi8(k, k), _mm_setzero_si128()));\n }\n default:\n Vc_UNREACHABLE();\n }\n}\n\ntemplate \nVc_INTRINSIC R mask_load(const bool *mem, Flags,\n enable_if::value> = nullarg)\n{\n static_assert(\n N == 4 || N == 8 || N == 16,\n \"mask_load<__m256>(const bool *) is only implemented for 4, 8, and 16 entries\");\n switch (N) {\n case 4: {\n __m128i k = AVX::avx_cast<__m128i>(_mm_and_ps(\n _mm_set1_ps(*aliasing_cast(mem)),\n AVX::avx_cast<__m128>(_mm_setr_epi32(0x1, 0x100, 0x10000, 0x1000000))));\n k = _mm_cmpgt_epi32(k, _mm_setzero_si128());\n return AVX::avx_cast<__m256>(\n AVX::concat(_mm_unpacklo_epi32(k, k), _mm_unpackhi_epi32(k, k)));\n }\n case 8: {\n#ifdef __x86_64__\n __m128i k = _mm_cvtsi64_si128(*aliasing_cast(mem));\n#else\n __m128i k = _mm_castpd_si128(_mm_load_sd(aliasing_cast(mem)));\n#endif\n k = _mm_cmpgt_epi16(_mm_unpacklo_epi8(k, k), _mm_setzero_si128());\n return AVX::avx_cast<__m256>(\n AVX::concat(_mm_unpacklo_epi16(k, k), _mm_unpackhi_epi16(k, k)));\n }\n case 16: {\n const auto k128 = _mm_cmpgt_epi8(\n Flags::IsAligned ? _mm_load_si128(reinterpret_cast(mem))\n : _mm_loadu_si128(reinterpret_cast(mem)),\n _mm_setzero_si128());\n return AVX::avx_cast<__m256>(\n AVX::concat(_mm_unpacklo_epi8(k128, k128), _mm_unpackhi_epi8(k128, k128)));\n }\n default:\n Vc_UNREACHABLE();\n return R();\n }\n}\n\n// mask_to_int{{{1\ntemplate \nVc_INTRINSIC_L Vc_CONST_L int mask_to_int(__m256i x) Vc_INTRINSIC_R Vc_CONST_R;\ntemplate <> Vc_INTRINSIC Vc_CONST int mask_to_int<4>(__m256i k)\n{\n return movemask(AVX::avx_cast<__m256d>(k));\n}\ntemplate <> Vc_INTRINSIC Vc_CONST int mask_to_int<8>(__m256i k)\n{\n return movemask(AVX::avx_cast<__m256>(k));\n}\n#ifdef Vc_IMPL_BMI2\ntemplate <> Vc_INTRINSIC Vc_CONST int mask_to_int<16>(__m256i k)\n{\n return _pext_u32(movemask(k), 0x55555555u);\n}\n#endif\ntemplate <> Vc_INTRINSIC Vc_CONST int mask_to_int<32>(__m256i k)\n{\n return movemask(k);\n}\n\n//InterleaveImpl{{{1\ntemplate struct InterleaveImpl {\n template static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/\n const typename V::AsArg v0, // a0 a1 a2 a3 a4 a5 a6 a7 | a8 a9 ...\n const typename V::AsArg v1) // b0 b1 b2 b3 b4 b5 b6 b7 | b8 b9 ...\n {\n const __m256i tmp0 = AVX::unpacklo_epi16(v0.data(), v1.data()); // a0 b0 a1 b1 a2 b2 a3 b3 | a8 b8 a9 ...\n const __m256i tmp1 = AVX::unpackhi_epi16(v0.data(), v1.data()); // a4 b4 a5 ...\n using namespace AVX;\n *aliasing_cast(&data[i[ 0]]) = _mm_cvtsi128_si32(lo128(tmp0));\n *aliasing_cast(&data[i[ 1]]) = _mm_extract_epi32(lo128(tmp0), 1);\n *aliasing_cast(&data[i[ 2]]) = _mm_extract_epi32(lo128(tmp0), 2);\n *aliasing_cast(&data[i[ 3]]) = _mm_extract_epi32(lo128(tmp0), 3);\n *aliasing_cast(&data[i[ 4]]) = _mm_cvtsi128_si32(lo128(tmp1));\n *aliasing_cast(&data[i[ 5]]) = _mm_extract_epi32(lo128(tmp1), 1);\n *aliasing_cast(&data[i[ 6]]) = _mm_extract_epi32(lo128(tmp1), 2);\n *aliasing_cast(&data[i[ 7]]) = _mm_extract_epi32(lo128(tmp1), 3);\n *aliasing_cast(&data[i[ 8]]) = _mm_cvtsi128_si32(hi128(tmp0));\n *aliasing_cast(&data[i[ 9]]) = _mm_extract_epi32(hi128(tmp0), 1);\n *aliasing_cast(&data[i[10]]) = _mm_extract_epi32(hi128(tmp0), 2);\n *aliasing_cast(&data[i[11]]) = _mm_extract_epi32(hi128(tmp0), 3);\n *aliasing_cast(&data[i[12]]) = _mm_cvtsi128_si32(hi128(tmp1));\n *aliasing_cast(&data[i[13]]) = _mm_extract_epi32(hi128(tmp1), 1);\n *aliasing_cast(&data[i[14]]) = _mm_extract_epi32(hi128(tmp1), 2);\n *aliasing_cast(&data[i[15]]) = _mm_extract_epi32(hi128(tmp1), 3);\n }/*}}}*/\n static inline void interleave(typename V::EntryType *const data, const Common::SuccessiveEntries<2> &i,/*{{{*/\n const typename V::AsArg v0, const typename V::AsArg v1)\n {\n const __m256i tmp0 = AVX::unpacklo_epi16(v0.data(), v1.data()); // a0 b0 a1 b1 a2 b2 a3 b3 | a8 b8 a9 ...\n const __m256i tmp1 = AVX::unpackhi_epi16(v0.data(), v1.data()); // a4 b4 a5 ...\n V(Mem::shuffle128(tmp0, tmp1)).store(&data[i[0]], Vc::Unaligned);\n V(Mem::shuffle128(tmp0, tmp1)).store(&data[i[8]], Vc::Unaligned);\n }/*}}}*/\n template static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/\n const typename V::AsArg v0, const typename V::AsArg v1, const typename V::AsArg v2)\n {\n interleave(data, i, v0, v1);\n v2.scatter(data + 2, i);\n }/*}}}*/\n template static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3)\n {\n const __m256i tmp0 = AVX::unpacklo_epi16(v0.data(), v2.data()); // a0 c0 a1 c1 a2 c2 a3 c3 | a8 c8 a9 c9 ...\n const __m256i tmp1 = AVX::unpackhi_epi16(v0.data(), v2.data()); // a4 c4 a5 c5 a6 c6 a7 c7 | a12 c12 ...\n const __m256i tmp2 = AVX::unpacklo_epi16(v1.data(), v3.data()); // b0 d0 b1 d1 b2 d2 b3 d3 | b8 d8 b9 d9 ...\n const __m256i tmp3 = AVX::unpackhi_epi16(v1.data(), v3.data()); // b4 d4 b5 ...\n\n const __m256i tmp4 = AVX::unpacklo_epi16(tmp0, tmp2); // a0 b0 c0 d0 a1 b1 c1 d1 | a8 b8 c8 d8 a9 b9 ...\n const __m256i tmp5 = AVX::unpackhi_epi16(tmp0, tmp2); // [abcd]2 [abcd]3 | [abcd]10 [abcd]11\n const __m256i tmp6 = AVX::unpacklo_epi16(tmp1, tmp3); // [abcd]4 [abcd]5 | [abcd]12 [abcd]13\n const __m256i tmp7 = AVX::unpackhi_epi16(tmp1, tmp3); // [abcd]6 [abcd]7 | [abcd]14 [abcd]15\n\n using namespace AVX;\n auto &&store = [&](__m256i x, int offset) {\n _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[offset + 0]]), lo128(x));\n _mm_storel_epi64(reinterpret_cast<__m128i *>(&data[i[offset + 8]]), hi128(x));\n _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[offset + 1]]), avx_cast<__m128>(x));\n _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[offset + 9]]), avx_cast<__m128>(hi128(x)));\n };\n store(tmp4, 0);\n store(tmp5, 2);\n store(tmp6, 4);\n store(tmp7, 6);\n }/*}}}*/\n static inline void interleave(typename V::EntryType *const data, const Common::SuccessiveEntries<4> &i,/*{{{*/\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3)\n {\n const __m256i tmp0 = AVX::unpacklo_epi16(v0.data(), v2.data()); // a0 c0 a1 c1 a2 c2 a3 c3 | a8 c8 a9 c9 ...\n const __m256i tmp1 = AVX::unpackhi_epi16(v0.data(), v2.data()); // a4 c4 a5 c5 a6 c6 a7 c7 | a12 c12 ...\n const __m256i tmp2 = AVX::unpacklo_epi16(v1.data(), v3.data()); // b0 d0 b1 d1 b2 d2 b3 d3 | b8 d8 b9 d9 ...\n const __m256i tmp3 = AVX::unpackhi_epi16(v1.data(), v3.data()); // b4 d4 b5 ...\n\n const __m256i tmp4 = AVX::unpacklo_epi16(tmp0, tmp2); // a0 b0 c0 d0 a1 b1 c1 d1 | a8 b8 c8 d8 a9 b9 ...\n const __m256i tmp5 = AVX::unpackhi_epi16(tmp0, tmp2); // [abcd]2 [abcd]3 | [abcd]10 [abcd]11\n const __m256i tmp6 = AVX::unpacklo_epi16(tmp1, tmp3); // [abcd]4 [abcd]5 | [abcd]12 [abcd]13\n const __m256i tmp7 = AVX::unpackhi_epi16(tmp1, tmp3); // [abcd]6 [abcd]7 | [abcd]14 [abcd]15\n\n V(Mem::shuffle128(tmp4, tmp5)).store(&data[i[0]], ::Vc::Unaligned);\n V(Mem::shuffle128(tmp6, tmp7)).store(&data[i[4]], ::Vc::Unaligned);\n V(Mem::shuffle128(tmp4, tmp5)).store(&data[i[8]], ::Vc::Unaligned);\n V(Mem::shuffle128(tmp6, tmp7)).store(&data[i[12]], ::Vc::Unaligned);\n }/*}}}*/\n template // interleave 5 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4)\n {\n interleave(data, i, v0, v1, v2, v3);\n v4.scatter(data + 4, i);\n }\n template // interleave 6 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4, const typename V::AsArg v5)\n {\n interleave(data, i, v0, v1, v2, v3);\n interleave(data + 4, i, v4, v5);\n }\n template // interleave 7 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4, const typename V::AsArg v5,\n const typename V::AsArg v6)\n {\n interleave(data, i, v0, v1, v2, v3);\n interleave(data + 4, i, v4, v5, v6);\n }\n template // interleave 8 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4, const typename V::AsArg v5,\n const typename V::AsArg v6, const typename V::AsArg v7)\n {\n interleave(data, i, v0, v1, v2, v3);\n interleave(data + 4, i, v4, v5, v6, v7);\n }\n //}}}2\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1)\n {\n const __m256i tmp4 = // a0 b0 a1 b1 a2 b2 a3 b3 | a8 b8 a9 b9 a10 b10 a11 b11\n _mm256_setr_epi32(\n *aliasing_cast(&data[i[0]]), *aliasing_cast(&data[i[1]]),\n *aliasing_cast(&data[i[2]]), *aliasing_cast(&data[i[3]]),\n *aliasing_cast(&data[i[8]]), *aliasing_cast(&data[i[9]]),\n *aliasing_cast(&data[i[10]]), *aliasing_cast(&data[i[11]]));\n const __m256i tmp5 = // a4 b4 a5 b5 a6 b6 a7 b7 | a12 b12 a13 b13 a14 b14 a15 b15\n _mm256_setr_epi32(\n *aliasing_cast(&data[i[4]]), *aliasing_cast(&data[i[5]]),\n *aliasing_cast(&data[i[6]]), *aliasing_cast(&data[i[7]]),\n *aliasing_cast(&data[i[12]]), *aliasing_cast(&data[i[13]]),\n *aliasing_cast(&data[i[14]]), *aliasing_cast(&data[i[15]]));\n\n const __m256i tmp2 = AVX::unpacklo_epi16(tmp4, tmp5); // a0 a4 b0 b4 a1 a5 b1 b5 | a8 a12 b8 b12 a9 a13 b9 b13\n const __m256i tmp3 = AVX::unpackhi_epi16(tmp4, tmp5); // a2 a6 b2 b6 a3 a7 b3 b7 | a10 a14 b10 b14 a11 a15 b11 b15\n\n const __m256i tmp0 = AVX::unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6 | a8 a10 a12 a14 b8 ...\n const __m256i tmp1 = AVX::unpackhi_epi16(tmp2, tmp3); // a1 a3 a5 a7 b1 b3 b5 b7 | a9 a11 a13 a15 b9 ...\n\n v0.data() = AVX::unpacklo_epi16(tmp0, tmp1); // a0 a1 a2 a3 a4 a5 a6 a7 | a8 a9 ...\n v1.data() = AVX::unpackhi_epi16(tmp0, tmp1); // b0 b1 b2 b3 b4 b5 b6 b7 | b8 b9 ...\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2)\n {\n using namespace AVX;\n const __m256i tmp0 = avx_cast<__m256i>(_mm256_setr_pd(\n *aliasing_cast(&data[i[0]]), *aliasing_cast(&data[i[1]]),\n *aliasing_cast(&data[i[8]]), *aliasing_cast(&data[i[9]])));\n const __m256i tmp1 = avx_cast<__m256i>(_mm256_setr_pd(\n *aliasing_cast(&data[i[2]]), *aliasing_cast(&data[i[3]]),\n *aliasing_cast(&data[i[10]]), *aliasing_cast(&data[i[11]])));\n const __m256i tmp2 = avx_cast<__m256i>(_mm256_setr_pd(\n *aliasing_cast(&data[i[4]]), *aliasing_cast(&data[i[5]]),\n *aliasing_cast(&data[i[12]]), *aliasing_cast(&data[i[13]])));\n const __m256i tmp3 = avx_cast<__m256i>(_mm256_setr_pd(\n *aliasing_cast(&data[i[6]]), *aliasing_cast(&data[i[7]]),\n *aliasing_cast(&data[i[14]]), *aliasing_cast(&data[i[15]])));\n const __m256i tmp4 = AVX::unpacklo_epi16(tmp0, tmp2); // a0 a4 b0 b4 c0 c4 XX XX | a8 a12 b8 ...\n const __m256i tmp5 = AVX::unpackhi_epi16(tmp0, tmp2); // a1 a5 ...\n const __m256i tmp6 = AVX::unpacklo_epi16(tmp1, tmp3); // a2 a6 ...\n const __m256i tmp7 = AVX::unpackhi_epi16(tmp1, tmp3); // a3 a7 ...\n\n const __m256i tmp8 = AVX::unpacklo_epi16(tmp4, tmp6); // a0 a2 a4 a6 b0 ...\n const __m256i tmp9 = AVX::unpackhi_epi16(tmp4, tmp6); // c0 c2 c4 c6 XX ...\n const __m256i tmp10 = AVX::unpacklo_epi16(tmp5, tmp7); // a1 a3 a5 a7 b1 ...\n const __m256i tmp11 = AVX::unpackhi_epi16(tmp5, tmp7); // c1 c3 c5 c7 XX ...\n\n v0.data() = AVX::unpacklo_epi16(tmp8, tmp10); // a0 a1 a2 a3 a4 a5 a6 a7 | a8 ...\n v1.data() = AVX::unpackhi_epi16(tmp8, tmp10);\n v2.data() = AVX::unpacklo_epi16(tmp9, tmp11);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3)\n {\n using namespace AVX;\n const __m256i tmp0 = avx_cast<__m256i>(_mm256_setr_pd(\n *aliasing_cast(&data[i[0]]), *aliasing_cast(&data[i[1]]),\n *aliasing_cast(&data[i[8]]), *aliasing_cast(&data[i[9]])));\n const __m256i tmp1 = avx_cast<__m256i>(_mm256_setr_pd(\n *aliasing_cast(&data[i[2]]), *aliasing_cast(&data[i[3]]),\n *aliasing_cast(&data[i[10]]), *aliasing_cast(&data[i[11]])));\n const __m256i tmp2 = avx_cast<__m256i>(_mm256_setr_pd(\n *aliasing_cast(&data[i[4]]), *aliasing_cast(&data[i[5]]),\n *aliasing_cast(&data[i[12]]), *aliasing_cast(&data[i[13]])));\n const __m256i tmp3 = avx_cast<__m256i>(_mm256_setr_pd(\n *aliasing_cast(&data[i[6]]), *aliasing_cast(&data[i[7]]),\n *aliasing_cast(&data[i[14]]), *aliasing_cast(&data[i[15]])));\n const __m256i tmp4 = AVX::unpacklo_epi16(tmp0, tmp2); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 a12 b8 ...\n const __m256i tmp5 = AVX::unpackhi_epi16(tmp0, tmp2); // a1 a5 ...\n const __m256i tmp6 = AVX::unpacklo_epi16(tmp1, tmp3); // a2 a6 ...\n const __m256i tmp7 = AVX::unpackhi_epi16(tmp1, tmp3); // a3 a7 ...\n\n const __m256i tmp8 = AVX::unpacklo_epi16(tmp4, tmp6); // a0 a2 a4 a6 b0 ...\n const __m256i tmp9 = AVX::unpackhi_epi16(tmp4, tmp6); // c0 c2 c4 c6 d0 ...\n const __m256i tmp10 = AVX::unpacklo_epi16(tmp5, tmp7); // a1 a3 a5 a7 b1 ...\n const __m256i tmp11 = AVX::unpackhi_epi16(tmp5, tmp7); // c1 c3 c5 c7 d1 ...\n\n v0.data() = AVX::unpacklo_epi16(tmp8, tmp10); // a0 a1 a2 a3 a4 a5 a6 a7 | a8 ...\n v1.data() = AVX::unpackhi_epi16(tmp8, tmp10);\n v2.data() = AVX::unpacklo_epi16(tmp9, tmp11);\n v3.data() = AVX::unpackhi_epi16(tmp9, tmp11);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4)\n {\n using namespace AVX;\n const __m256i a = concat(_mm_loadu_si128(reinterpret_cast(&data[i[0]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[8]])));\n const __m256i b = concat(_mm_loadu_si128(reinterpret_cast(&data[i[1]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[9]])));\n const __m256i c = concat(_mm_loadu_si128(reinterpret_cast(&data[i[2]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[10]])));\n const __m256i d = concat(_mm_loadu_si128(reinterpret_cast(&data[i[3]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[11]])));\n const __m256i e = concat(_mm_loadu_si128(reinterpret_cast(&data[i[4]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[12]])));\n const __m256i f = concat(_mm_loadu_si128(reinterpret_cast(&data[i[5]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[13]])));\n const __m256i g = concat(_mm_loadu_si128(reinterpret_cast(&data[i[6]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[14]])));\n const __m256i h = concat(_mm_loadu_si128(reinterpret_cast(&data[i[7]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[15]])));\n\n const __m256i tmp2 = AVX::unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 ...\n const __m256i tmp4 = AVX::unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5\n const __m256i tmp3 = AVX::unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6\n const __m256i tmp5 = AVX::unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7\n const __m256i tmp10 = AVX::unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4\n const __m256i tmp11 = AVX::unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5\n const __m256i tmp12 = AVX::unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6\n const __m256i tmp13 = AVX::unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7\n\n const __m256i tmp0 = AVX::unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6 | a8 ...\n const __m256i tmp1 = AVX::unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7\n const __m256i tmp6 = AVX::unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6\n const __m256i tmp7 = AVX::unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7\n const __m256i tmp8 = AVX::unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6\n const __m256i tmp9 = AVX::unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7\n\n v0.data() = AVX::unpacklo_epi16(tmp0, tmp1);\n v1.data() = AVX::unpackhi_epi16(tmp0, tmp1);\n v2.data() = AVX::unpacklo_epi16(tmp6, tmp7);\n v3.data() = AVX::unpackhi_epi16(tmp6, tmp7);\n v4.data() = AVX::unpacklo_epi16(tmp8, tmp9);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)\n {\n using namespace AVX;\n const __m256i a = concat(_mm_loadu_si128(reinterpret_cast(&data[i[0]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[8]])));\n const __m256i b = concat(_mm_loadu_si128(reinterpret_cast(&data[i[1]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[9]])));\n const __m256i c = concat(_mm_loadu_si128(reinterpret_cast(&data[i[2]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[10]])));\n const __m256i d = concat(_mm_loadu_si128(reinterpret_cast(&data[i[3]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[11]])));\n const __m256i e = concat(_mm_loadu_si128(reinterpret_cast(&data[i[4]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[12]])));\n const __m256i f = concat(_mm_loadu_si128(reinterpret_cast(&data[i[5]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[13]])));\n const __m256i g = concat(_mm_loadu_si128(reinterpret_cast(&data[i[6]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[14]])));\n const __m256i h = concat(_mm_loadu_si128(reinterpret_cast(&data[i[7]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[15]])));\n\n const __m256i tmp2 = AVX::unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 ...\n const __m256i tmp4 = AVX::unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5\n const __m256i tmp3 = AVX::unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6\n const __m256i tmp5 = AVX::unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7\n const __m256i tmp10 = AVX::unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4\n const __m256i tmp11 = AVX::unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5\n const __m256i tmp12 = AVX::unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6\n const __m256i tmp13 = AVX::unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7\n\n const __m256i tmp0 = AVX::unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6 | a8 ...\n const __m256i tmp1 = AVX::unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7\n const __m256i tmp6 = AVX::unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6\n const __m256i tmp7 = AVX::unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7\n const __m256i tmp8 = AVX::unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6\n const __m256i tmp9 = AVX::unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7\n\n v0.data() = AVX::unpacklo_epi16(tmp0, tmp1);\n v1.data() = AVX::unpackhi_epi16(tmp0, tmp1);\n v2.data() = AVX::unpacklo_epi16(tmp6, tmp7);\n v3.data() = AVX::unpackhi_epi16(tmp6, tmp7);\n v4.data() = AVX::unpacklo_epi16(tmp8, tmp9);\n v5.data() = AVX::unpackhi_epi16(tmp8, tmp9);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)\n {\n using namespace AVX;\n const __m256i a = concat(_mm_loadu_si128(reinterpret_cast(&data[i[0]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[8]])));\n const __m256i b = concat(_mm_loadu_si128(reinterpret_cast(&data[i[1]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[9]])));\n const __m256i c = concat(_mm_loadu_si128(reinterpret_cast(&data[i[2]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[10]])));\n const __m256i d = concat(_mm_loadu_si128(reinterpret_cast(&data[i[3]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[11]])));\n const __m256i e = concat(_mm_loadu_si128(reinterpret_cast(&data[i[4]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[12]])));\n const __m256i f = concat(_mm_loadu_si128(reinterpret_cast(&data[i[5]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[13]])));\n const __m256i g = concat(_mm_loadu_si128(reinterpret_cast(&data[i[6]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[14]])));\n const __m256i h = concat(_mm_loadu_si128(reinterpret_cast(&data[i[7]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[15]])));\n\n const __m256i tmp2 = AVX::unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 ...\n const __m256i tmp4 = AVX::unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5\n const __m256i tmp3 = AVX::unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6\n const __m256i tmp5 = AVX::unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7\n const __m256i tmp10 = AVX::unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4\n const __m256i tmp11 = AVX::unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5\n const __m256i tmp12 = AVX::unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6\n const __m256i tmp13 = AVX::unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7\n\n const __m256i tmp0 = AVX::unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6 | a8 ...\n const __m256i tmp1 = AVX::unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7\n const __m256i tmp6 = AVX::unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6\n const __m256i tmp7 = AVX::unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7\n const __m256i tmp8 = AVX::unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6\n const __m256i tmp9 = AVX::unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7\n const __m256i tmp14 = AVX::unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6\n const __m256i tmp15 = AVX::unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7\n\n v0.data() = AVX::unpacklo_epi16(tmp0, tmp1);\n v1.data() = AVX::unpackhi_epi16(tmp0, tmp1);\n v2.data() = AVX::unpacklo_epi16(tmp6, tmp7);\n v3.data() = AVX::unpackhi_epi16(tmp6, tmp7);\n v4.data() = AVX::unpacklo_epi16(tmp8, tmp9);\n v5.data() = AVX::unpackhi_epi16(tmp8, tmp9);\n v6.data() = AVX::unpacklo_epi16(tmp14, tmp15);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7)\n {\n using namespace AVX;\n const __m256i a = concat(_mm_loadu_si128(reinterpret_cast(&data[i[0]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[8]])));\n const __m256i b = concat(_mm_loadu_si128(reinterpret_cast(&data[i[1]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[9]])));\n const __m256i c = concat(_mm_loadu_si128(reinterpret_cast(&data[i[2]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[10]])));\n const __m256i d = concat(_mm_loadu_si128(reinterpret_cast(&data[i[3]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[11]])));\n const __m256i e = concat(_mm_loadu_si128(reinterpret_cast(&data[i[4]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[12]])));\n const __m256i f = concat(_mm_loadu_si128(reinterpret_cast(&data[i[5]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[13]])));\n const __m256i g = concat(_mm_loadu_si128(reinterpret_cast(&data[i[6]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[14]])));\n const __m256i h = concat(_mm_loadu_si128(reinterpret_cast(&data[i[7]])),\n _mm_loadu_si128(reinterpret_cast(&data[i[15]])));\n\n const __m256i tmp2 = AVX::unpacklo_epi16(a, e); // a0 a4 b0 b4 c0 c4 d0 d4 | a8 ...\n const __m256i tmp4 = AVX::unpacklo_epi16(b, f); // a1 a5 b1 b5 c1 c5 d1 d5\n const __m256i tmp3 = AVX::unpacklo_epi16(c, g); // a2 a6 b2 b6 c2 c6 d2 d6\n const __m256i tmp5 = AVX::unpacklo_epi16(d, h); // a3 a7 b3 b7 c3 c7 d3 d7\n const __m256i tmp10 = AVX::unpackhi_epi16(a, e); // e0 e4 f0 f4 g0 g4 h0 h4\n const __m256i tmp11 = AVX::unpackhi_epi16(c, g); // e1 e5 f1 f5 g1 g5 h1 h5\n const __m256i tmp12 = AVX::unpackhi_epi16(b, f); // e2 e6 f2 f6 g2 g6 h2 h6\n const __m256i tmp13 = AVX::unpackhi_epi16(d, h); // e3 e7 f3 f7 g3 g7 h3 h7\n\n const __m256i tmp0 = AVX::unpacklo_epi16(tmp2, tmp3); // a0 a2 a4 a6 b0 b2 b4 b6 | a8 ...\n const __m256i tmp1 = AVX::unpacklo_epi16(tmp4, tmp5); // a1 a3 a5 a7 b1 b3 b5 b7\n const __m256i tmp6 = AVX::unpackhi_epi16(tmp2, tmp3); // c0 c2 c4 c6 d0 d2 d4 d6\n const __m256i tmp7 = AVX::unpackhi_epi16(tmp4, tmp5); // c1 c3 c5 c7 d1 d3 d5 d7\n const __m256i tmp8 = AVX::unpacklo_epi16(tmp10, tmp11); // e0 e2 e4 e6 f0 f2 f4 f6\n const __m256i tmp9 = AVX::unpacklo_epi16(tmp12, tmp13); // e1 e3 e5 e7 f1 f3 f5 f7\n const __m256i tmp14 = AVX::unpackhi_epi16(tmp10, tmp11); // g0 g2 g4 g6 h0 h2 h4 h6\n const __m256i tmp15 = AVX::unpackhi_epi16(tmp12, tmp13); // g1 g3 g5 g7 h1 h3 h5 h7\n\n v0.data() = AVX::unpacklo_epi16(tmp0, tmp1);\n v1.data() = AVX::unpackhi_epi16(tmp0, tmp1);\n v2.data() = AVX::unpacklo_epi16(tmp6, tmp7);\n v3.data() = AVX::unpackhi_epi16(tmp6, tmp7);\n v4.data() = AVX::unpacklo_epi16(tmp8, tmp9);\n v5.data() = AVX::unpackhi_epi16(tmp8, tmp9);\n v6.data() = AVX::unpacklo_epi16(tmp14, tmp15);\n v7.data() = AVX::unpackhi_epi16(tmp14, tmp15);\n }/*}}}*/\n};\ntemplate struct InterleaveImpl {\n static_assert(sizeof(typename V::value_type) == 4, \"\");\n template static inline void interleave(typename V::EntryType *const data, const I &i,/*{{{*/\n const typename V::AsArg v0, const typename V::AsArg v1)\n {\n using namespace AVX;\n // [0a 1a 0b 1b 0e 1e 0f 1f]:\n const m256 tmp0 = _mm256_unpacklo_ps(avx_cast(v0.data()), avx_cast(v1.data()));\n // [0c 1c 0d 1d 0g 1g 0h 1h]:\n const m256 tmp1 = _mm256_unpackhi_ps(avx_cast(v0.data()), avx_cast(v1.data()));\n _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[0]]), lo128(tmp0));\n _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[1]]), lo128(tmp0));\n _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[2]]), lo128(tmp1));\n _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[3]]), lo128(tmp1));\n _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[4]]), hi128(tmp0));\n _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[5]]), hi128(tmp0));\n _mm_storel_pi(reinterpret_cast<__m64 *>(&data[i[6]]), hi128(tmp1));\n _mm_storeh_pi(reinterpret_cast<__m64 *>(&data[i[7]]), hi128(tmp1));\n }/*}}}*/\n static inline void interleave(typename V::EntryType *const data, const Common::SuccessiveEntries<2> &i,/*{{{*/\n const typename V::AsArg v0, const typename V::AsArg v1)\n {\n using namespace AVX;\n // [0a 1a 0b 1b 0e 1e 0f 1f]:\n const m256 tmp0 = _mm256_unpacklo_ps(avx_cast(v0.data()), avx_cast(v1.data()));\n // [0c 1c 0d 1d 0g 1g 0h 1h]:\n const m256 tmp1 = _mm256_unpackhi_ps(avx_cast(v0.data()), avx_cast(v1.data()));\n _mm_storeu_ps(aliasing_cast(&data[i[0]]), lo128(tmp0));\n _mm_storeu_ps(aliasing_cast(&data[i[2]]), lo128(tmp1));\n _mm_storeu_ps(aliasing_cast(&data[i[4]]), hi128(tmp0));\n _mm_storeu_ps(aliasing_cast(&data[i[6]]), hi128(tmp1));\n }/*}}}*/\n // interleave scatter 3 {{{\n template \n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2)\n {\n using namespace AVX;\n#ifdef Vc_USE_MASKMOV_SCATTER\n // [0a 2a 0b 2b 0e 2e 0f 2f]:\n const m256 tmp0 = _mm256_unpacklo_ps(avx_cast(v0.data()), avx_cast(v2.data()));\n // [0c 2c 0d 2d 0g 2g 0h 2h]:\n const m256 tmp1 = _mm256_unpackhi_ps(avx_cast(v0.data()), avx_cast(v2.data()));\n // [1a __ 1b __ 1e __ 1f __]:\n const m256 tmp2 = _mm256_unpacklo_ps(avx_cast(v1.data()), avx_cast(v1.data()));\n // [1c __ 1d __ 1g __ 1h __]:\n const m256 tmp3 = _mm256_unpackhi_ps(avx_cast(v1.data()), avx_cast(v1.data()));\n const m256 tmp4 = _mm256_unpacklo_ps(tmp0, tmp2);\n const m256 tmp5 = _mm256_unpackhi_ps(tmp0, tmp2);\n const m256 tmp6 = _mm256_unpacklo_ps(tmp1, tmp3);\n const m256 tmp7 = _mm256_unpackhi_ps(tmp1, tmp3);\n const m128i mask = _mm_set_epi32(0, -1, -1, -1);\n _mm_maskstore_ps(aliasing_cast(&data[i[0]]), mask, lo128(tmp4));\n _mm_maskstore_ps(aliasing_cast(&data[i[1]]), mask, lo128(tmp5));\n _mm_maskstore_ps(aliasing_cast(&data[i[2]]), mask, lo128(tmp6));\n _mm_maskstore_ps(aliasing_cast(&data[i[3]]), mask, lo128(tmp7));\n _mm_maskstore_ps(aliasing_cast(&data[i[4]]), mask, hi128(tmp4));\n _mm_maskstore_ps(aliasing_cast(&data[i[5]]), mask, hi128(tmp5));\n _mm_maskstore_ps(aliasing_cast(&data[i[6]]), mask, hi128(tmp6));\n _mm_maskstore_ps(aliasing_cast(&data[i[7]]), mask, hi128(tmp7));\n#else\n interleave(data, i, v0, v1);\n v2.scatter(data + 2, i);\n#endif\n } // }}}\n // interleave successive 3 {{{\n static inline void interleave(typename V::EntryType *const data,\n const Common::SuccessiveEntries<3> &i,\n const typename V::AsArg v0_,\n const typename V::AsArg v1_,\n const typename V::AsArg v2_)\n {\n __m256 v0 = AVX::avx_cast<__m256>(v0_.data()); // a0 a1 a2 a3|a4 a5 a6 a7\n __m256 v1 = AVX::avx_cast<__m256>(v1_.data()); // b0 b1 b2 b3|b4 b5 b6 b7\n __m256 v2 = AVX::avx_cast<__m256>(v2_.data()); // c0 c1 c2 c3|c4 c5 c6 c7\n\n v0 = _mm256_shuffle_ps(v0, v0, 0x6c); // a0 a3 a2 a1|a4 a7 a6 a5\n v1 = _mm256_shuffle_ps(v1, v1, 0xb1); // b1 b0 b3 b2|b5 b4 b7 b6\n v2 = _mm256_shuffle_ps(v2, v2, 0xc6); // c2 c1 c0 c3|c6 c5 c4 c7\n\n // a0 b0 c0 a1|c6 a7 b7 c7:\n __m256 w0 = Mem::blend(\n Mem::blend(v0, v1), v2);\n // b1 c1 a2 b2|b5 c5 a6 b6:\n __m256 w1 = Mem::blend(\n Mem::blend(v0, v1), v2);\n // c2 a3 b3 c3|a4 b4 c4 a5:\n __m256 w2 = Mem::blend(\n Mem::blend(v0, v1), v2);\n\n // a0 b0 c0 a1|b1 c1 a2 b2:\n _mm256_storeu_ps(aliasing_cast(&data[i[0]]),\n _mm256_permute2f128_ps(w0, w1, 0x20));\n // c2 a3 b3 c3|a4 b4 c4 a5: w2\n _mm256_storeu_ps(aliasing_cast(&data[i[0]] + 8), w2);\n // b5 c5 a6 b6|c6 a7 b7 c7:\n _mm256_storeu_ps(aliasing_cast(&data[i[0]] + 16),\n _mm256_permute2f128_ps(w1, w0, 0x31));\n\n } //}}}\n // interleave scatter 4 {{{\n template \n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3)\n {\n using namespace AVX;\n const __m256 tmp0 =\n _mm256_unpacklo_ps(avx_cast(v0.data()), avx_cast(v2.data()));\n const __m256 tmp1 =\n _mm256_unpackhi_ps(avx_cast(v0.data()), avx_cast(v2.data()));\n const __m256 tmp2 =\n _mm256_unpacklo_ps(avx_cast(v1.data()), avx_cast(v3.data()));\n const __m256 tmp3 =\n _mm256_unpackhi_ps(avx_cast(v1.data()), avx_cast(v3.data()));\n const __m256 _04 = _mm256_unpacklo_ps(tmp0, tmp2);\n const __m256 _15 = _mm256_unpackhi_ps(tmp0, tmp2);\n const __m256 _26 = _mm256_unpacklo_ps(tmp1, tmp3);\n const __m256 _37 = _mm256_unpackhi_ps(tmp1, tmp3);\n _mm_storeu_ps(aliasing_cast(&data[i[0]]), lo128(_04));\n _mm_storeu_ps(aliasing_cast(&data[i[1]]), lo128(_15));\n _mm_storeu_ps(aliasing_cast(&data[i[2]]), lo128(_26));\n _mm_storeu_ps(aliasing_cast(&data[i[3]]), lo128(_37));\n _mm_storeu_ps(aliasing_cast(&data[i[4]]), hi128(_04));\n _mm_storeu_ps(aliasing_cast(&data[i[5]]), hi128(_15));\n _mm_storeu_ps(aliasing_cast(&data[i[6]]), hi128(_26));\n _mm_storeu_ps(aliasing_cast(&data[i[7]]), hi128(_37));\n } // }}}\n // interleave successive 4 {{{\n // same as above except fot the stores, that can be combined to 256-bit stores\n static inline void interleave(typename V::EntryType *const data,\n const Common::SuccessiveEntries<4> &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3)\n {\n using namespace AVX;\n const __m256 tmp0 =\n _mm256_unpacklo_ps(avx_cast(v0.data()), avx_cast(v2.data()));\n const __m256 tmp1 =\n _mm256_unpackhi_ps(avx_cast(v0.data()), avx_cast(v2.data()));\n const __m256 tmp2 =\n _mm256_unpacklo_ps(avx_cast(v1.data()), avx_cast(v3.data()));\n const __m256 tmp3 =\n _mm256_unpackhi_ps(avx_cast(v1.data()), avx_cast(v3.data()));\n const __m256 _04 = _mm256_unpacklo_ps(tmp0, tmp2);\n const __m256 _15 = _mm256_unpackhi_ps(tmp0, tmp2);\n const __m256 _26 = _mm256_unpacklo_ps(tmp1, tmp3);\n const __m256 _37 = _mm256_unpackhi_ps(tmp1, tmp3);\n _mm256_storeu_ps(aliasing_cast(&data[i[0]]),\n _mm256_permute2f128_ps(_04, _15, 0x20));\n _mm256_storeu_ps(aliasing_cast(&data[i[0]] + 8),\n _mm256_permute2f128_ps(_26, _37, 0x20));\n _mm256_storeu_ps(aliasing_cast(&data[i[0]] + 16),\n _mm256_permute2f128_ps(_04, _15, 0x31));\n _mm256_storeu_ps(aliasing_cast(&data[i[0]] + 24),\n _mm256_permute2f128_ps(_26, _37, 0x31));\n } // }}}\n template // interleave 5 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4)\n {\n interleave(data, i, v0, v1, v2, v3);\n v4.scatter(data + 4, i);\n }\n template // interleave 6 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4, const typename V::AsArg v5)\n {\n interleave(data, i, v0, v1, v2, v3);\n interleave(data + 4, i, v4, v5);\n }\n template // interleave 7 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4, const typename V::AsArg v5,\n const typename V::AsArg v6)\n {\n interleave(data, i, v0, v1, v2, v3);\n interleave(data + 4, i, v4, v5, v6);\n }\n template // interleave 8 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4, const typename V::AsArg v5,\n const typename V::AsArg v6, const typename V::AsArg v7)\n {\n interleave(data, i, v0, v1, v2, v3);\n interleave(data + 4, i, v4, v5, v6, v7);\n }\n //}}}2\n // deinterleave scatter 2 {{{\n template \n static inline void deinterleave(typename V::EntryType const *const data, const I &i,\n V &v0, V &v1)\n {\n using namespace AVX;\n const m128 il0 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&data[i[0]])); // a0 b0\n const m128 il2 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&data[i[2]])); // a2 b2\n const m128 il4 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&data[i[4]])); // a4 b4\n const m128 il6 = _mm_loadl_pi(_mm_setzero_ps(), reinterpret_cast<__m64 const *>(&data[i[6]])); // a6 b6\n const m128 il01 = _mm_loadh_pi( il0, reinterpret_cast<__m64 const *>(&data[i[1]])); // a0 b0 a1 b1\n const m128 il23 = _mm_loadh_pi( il2, reinterpret_cast<__m64 const *>(&data[i[3]])); // a2 b2 a3 b3\n const m128 il45 = _mm_loadh_pi( il4, reinterpret_cast<__m64 const *>(&data[i[5]])); // a4 b4 a5 b5\n const m128 il67 = _mm_loadh_pi( il6, reinterpret_cast<__m64 const *>(&data[i[7]])); // a6 b6 a7 b7\n\n const m256 tmp2 = concat(il01, il45);\n const m256 tmp3 = concat(il23, il67);\n\n const m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);\n const m256 tmp1 = _mm256_unpackhi_ps(tmp2, tmp3);\n\n v0.data() = avx_cast(_mm256_unpacklo_ps(tmp0, tmp1));\n v1.data() = avx_cast(_mm256_unpackhi_ps(tmp0, tmp1));\n } // }}}\n // deinterleave successive 2 {{{\n static inline void deinterleave(typename V::EntryType const *const data,\n const Common::SuccessiveEntries<2> &i, V &v0, V &v1)\n {\n using namespace AVX;\n const m256 il0123 = _mm256_loadu_ps(aliasing_cast(&data[i[0]])); // a0 b0 a1 b1 a2 b2 a3 b3\n const m256 il4567 = _mm256_loadu_ps(aliasing_cast(&data[i[4]])); // a4 b4 a5 b5 a6 b6 a7 b7\n\n const m256 tmp2 = Mem::shuffle128(il0123, il4567);\n const m256 tmp3 = Mem::shuffle128(il0123, il4567);\n\n const m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);\n const m256 tmp1 = _mm256_unpackhi_ps(tmp2, tmp3);\n\n v0.data() = avx_cast(_mm256_unpacklo_ps(tmp0, tmp1));\n v1.data() = avx_cast(_mm256_unpackhi_ps(tmp0, tmp1));\n } // }}}\n // deinterleave scatter 3 {{{\n template \n static inline void deinterleave(typename V::EntryType const *const data, const I &i,\n V &v0, V &v1, V &v2)\n {\n using namespace AVX;\n const m128 il0 = _mm_loadu_ps(aliasing_cast(&data[i[0]])); // a0 b0 c0 d0\n const m128 il1 = _mm_loadu_ps(aliasing_cast(&data[i[1]])); // a1 b1 c1 d1\n const m128 il2 = _mm_loadu_ps(aliasing_cast(&data[i[2]])); // a2 b2 c2 d2\n const m128 il3 = _mm_loadu_ps(aliasing_cast(&data[i[3]])); // a3 b3 c3 d3\n const m128 il4 = _mm_loadu_ps(aliasing_cast(&data[i[4]])); // a4 b4 c4 d4\n const m128 il5 = _mm_loadu_ps(aliasing_cast(&data[i[5]])); // a5 b5 c5 d5\n const m128 il6 = _mm_loadu_ps(aliasing_cast(&data[i[6]])); // a6 b6 c6 d6\n const m128 il7 = _mm_loadu_ps(aliasing_cast(&data[i[7]])); // a7 b7 c7 d7\n\n const m256 il04 = concat(il0, il4);\n const m256 il15 = concat(il1, il5);\n const m256 il26 = concat(il2, il6);\n const m256 il37 = concat(il3, il7);\n const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);\n const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);\n const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);\n const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);\n v0.data() = avx_cast(_mm256_unpacklo_ps(ab0246, ab1357));\n v1.data() = avx_cast(_mm256_unpackhi_ps(ab0246, ab1357));\n v2.data() = avx_cast(_mm256_unpacklo_ps(cd0246, cd1357));\n } // }}}\n // deinterleave successive 3 {{{\n static inline void deinterleave(typename V::EntryType const *const data,\n const Common::SuccessiveEntries<3> &i, V &v0, V &v1,\n V &v2)\n {\n // 0a 1a 2a 0b 1b 2b 0c 1c\n __m256 in0 = _mm256_loadu_ps(aliasing_cast(&data[i[0]] + 0));\n // 2c 0d 1d 2d 0e 1e 2e 0f\n __m256 in1 = _mm256_loadu_ps(aliasing_cast(&data[i[0]] + 8));\n // 1f 2f 0g 1g 2g 0h 1h 2h\n __m256 in2 = _mm256_loadu_ps(aliasing_cast(&data[i[0]] + 16));\n\n // swap(v0.hi, v2.lo):\n // [0a 1a 2a 0b 1f 2f 0g 1g]\n // [2c 0d 1d 2d 0e 1e 2e 0f]\n // [1b 2b 0c 1c 2g 0h 1h 2h]\n const __m256 aaabffgg = _mm256_permute2f128_ps(in0, in2, 0x20);\n const __m256 cdddeeef = in1;\n const __m256 bbccghhh = _mm256_permute2f128_ps(in0, in2, 0x31);\n // blend:\n // 0: [a d c b e h g f]\n // 1: [b a d c f e h g]\n // 2: [c b a d g f e h]\n const __m256 x0 = _mm256_blend_ps(\n _mm256_blend_ps(aaabffgg, cdddeeef, 0 + 2 + 0 + 0 + 0x10 + 0 + 0 + 0x80),\n bbccghhh, 0 + 0 + 4 + 0 + 0 + 0x20 + 0 + 0);\n const __m256 x1 = _mm256_blend_ps(\n _mm256_blend_ps(aaabffgg, cdddeeef, 0 + 0 + 4 + 0 + 0 + 0x20 + 0 + 0),\n bbccghhh, 1 + 0 + 0 + 8 + 0 + 0 + 0x40 + 0);\n const __m256 x2 = _mm256_blend_ps(\n _mm256_blend_ps(aaabffgg, cdddeeef, 1 + 0 + 0 + 8 + 0 + 0 + 0x40 + 0),\n bbccghhh, 0 + 2 + 0 + 0 + 0x10 + 0 + 0 + 0x80);\n // 0: [a d c b e h g f] >-perm(0, 3, 2, 1)-> [a b c d e f g h]\n // 1: [b a d c f e h g] >-perm(1, 0, 3, 2)-> [a b c d e f g h]\n // 2: [c b a d g f e h] >-perm(2, 1, 0, 3)-> [a b c d e f g h]\n v0 = AVX::avx_cast(_mm256_shuffle_ps(x0, x0, 0x6c));\n v1 = AVX::avx_cast(_mm256_shuffle_ps(x1, x1, 0xb1));\n v2 = AVX::avx_cast(_mm256_shuffle_ps(x2, x2, 0xc6));\n } // }}}\n // deinterleave scatter 4 {{{\n template \n static inline void deinterleave(typename V::EntryType const *const data, const I &i,\n V &v0, V &v1, V &v2, V &v3)\n {\n using namespace AVX;\n const m128 il0 = _mm_loadu_ps(aliasing_cast(&data[i[0]])); // a0 b0 c0 d0\n const m128 il1 = _mm_loadu_ps(aliasing_cast(&data[i[1]])); // a1 b1 c1 d1\n const m128 il2 = _mm_loadu_ps(aliasing_cast(&data[i[2]])); // a2 b2 c2 d2\n const m128 il3 = _mm_loadu_ps(aliasing_cast(&data[i[3]])); // a3 b3 c3 d3\n const m128 il4 = _mm_loadu_ps(aliasing_cast(&data[i[4]])); // a4 b4 c4 d4\n const m128 il5 = _mm_loadu_ps(aliasing_cast(&data[i[5]])); // a5 b5 c5 d5\n const m128 il6 = _mm_loadu_ps(aliasing_cast(&data[i[6]])); // a6 b6 c6 d6\n const m128 il7 = _mm_loadu_ps(aliasing_cast(&data[i[7]])); // a7 b7 c7 d7\n\n const m256 il04 = concat(il0, il4);\n const m256 il15 = concat(il1, il5);\n const m256 il26 = concat(il2, il6);\n const m256 il37 = concat(il3, il7);\n const m256 ab0246 = _mm256_unpacklo_ps(il04, il26);\n const m256 ab1357 = _mm256_unpacklo_ps(il15, il37);\n const m256 cd0246 = _mm256_unpackhi_ps(il04, il26);\n const m256 cd1357 = _mm256_unpackhi_ps(il15, il37);\n v0.data() = avx_cast(_mm256_unpacklo_ps(ab0246, ab1357));\n v1.data() = avx_cast(_mm256_unpackhi_ps(ab0246, ab1357));\n v2.data() = avx_cast(_mm256_unpacklo_ps(cd0246, cd1357));\n v3.data() = avx_cast(_mm256_unpackhi_ps(cd0246, cd1357));\n } // }}}\n // deinterleave successive 4 {{{\n static inline void deinterleave(typename V::EntryType const *const data,\n const Common::SuccessiveEntries<4> &i, V &v0, V &v1,\n V &v2, V &v3)\n {\n using namespace AVX;\n const __m256 il01 = _mm256_loadu_ps(\n aliasing_cast(&data[i[0]])); // a0 b0 c0 d0 | a1 b1 c1 d1\n const __m256 il23 = _mm256_loadu_ps(\n aliasing_cast(&data[i[2]])); // a2 b2 c2 d2 | a3 b3 c3 d3\n const __m256 il45 = _mm256_loadu_ps(\n aliasing_cast(&data[i[4]])); // a4 b4 c4 d4 | a5 b5 c5 d5\n const __m256 il67 = _mm256_loadu_ps(\n aliasing_cast(&data[i[6]])); // a6 b6 c6 d6 | a7 b7 c7 d7\n\n const __m256 il04 = _mm256_permute2f128_ps(il01, il45, 0x20);\n const __m256 il15 = _mm256_permute2f128_ps(il01, il45, 0x31);\n const __m256 il26 = _mm256_permute2f128_ps(il23, il67, 0x20);\n const __m256 il37 = _mm256_permute2f128_ps(il23, il67, 0x31);\n const __m256 ab0246 = _mm256_unpacklo_ps(il04, il26);\n const __m256 ab1357 = _mm256_unpacklo_ps(il15, il37);\n const __m256 cd0246 = _mm256_unpackhi_ps(il04, il26);\n const __m256 cd1357 = _mm256_unpackhi_ps(il15, il37);\n v0.data() = avx_cast(_mm256_unpacklo_ps(ab0246, ab1357));\n v1.data() = avx_cast(_mm256_unpackhi_ps(ab0246, ab1357));\n v2.data() = avx_cast(_mm256_unpacklo_ps(cd0246, cd1357));\n v3.data() = avx_cast(_mm256_unpackhi_ps(cd0246, cd1357));\n } // }}}\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4)\n {\n v4.gather(data + 4, i);\n deinterleave(data, i, v0, v1, v2, v3);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)\n {\n deinterleave(data, i, v0, v1, v2, v3);\n deinterleave(data + 4, i, v4, v5);\n }/*}}}*/\n static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const Common::SuccessiveEntries<6> &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)\n {\n using namespace AVX;\n const m256 a = _mm256_loadu_ps(aliasing_cast(&data[i[0]]));\n const m256 b = _mm256_loadu_ps(aliasing_cast(&data[i[0] + 1 * V::Size]));\n const m256 c = _mm256_loadu_ps(aliasing_cast(&data[i[0] + 2 * V::Size]));\n const m256 d = _mm256_loadu_ps(aliasing_cast(&data[i[0] + 3 * V::Size]));\n const m256 e = _mm256_loadu_ps(aliasing_cast(&data[i[0] + 4 * V::Size]));\n const m256 f = _mm256_loadu_ps(aliasing_cast(&data[i[0] + 5 * V::Size]));\n const __m256 tmp2 = Mem::shuffle128(a, d);\n const __m256 tmp3 = Mem::shuffle128(b, e);\n const __m256 tmp4 = Mem::shuffle128(a, d);\n const __m256 tmp5 = Mem::shuffle128(c, f);\n const __m256 tmp8 = Mem::shuffle128(b, e);\n const __m256 tmp9 = Mem::shuffle128(c, f);\n const __m256 tmp0 = _mm256_unpacklo_ps(tmp2, tmp3);\n const __m256 tmp1 = _mm256_unpackhi_ps(tmp4, tmp5);\n const __m256 tmp6 = _mm256_unpackhi_ps(tmp2, tmp3);\n const __m256 tmp7 = _mm256_unpacklo_ps(tmp8, tmp9);\n const __m256 tmp10 = _mm256_unpacklo_ps(tmp4, tmp5);\n const __m256 tmp11 = _mm256_unpackhi_ps(tmp8, tmp9);\n v0.data() = avx_cast(_mm256_unpacklo_ps(tmp0, tmp1));\n v1.data() = avx_cast(_mm256_unpackhi_ps(tmp0, tmp1));\n v2.data() = avx_cast(_mm256_unpacklo_ps(tmp6, tmp7));\n v3.data() = avx_cast(_mm256_unpackhi_ps(tmp6, tmp7));\n v4.data() = avx_cast(_mm256_unpacklo_ps(tmp10, tmp11));\n v5.data() = avx_cast(_mm256_unpackhi_ps(tmp10, tmp11));\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)\n {\n deinterleave(data, i, v0, v1, v2, v3);\n deinterleave(data + 4, i, v4, v5, v6);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7)\n {\n deinterleave(data, i, v0, v1, v2, v3);\n deinterleave(data + 4, i, v4, v5, v6, v7);\n }/*}}}*/\n};\ntemplate struct InterleaveImpl {\n template // interleave 2 args{{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1)\n {\n using namespace AVX;\n const m256d tmp0 = _mm256_unpacklo_pd(v0.data(), v1.data());\n const m256d tmp1 = _mm256_unpackhi_pd(v0.data(), v1.data());\n _mm_storeu_pd(&data[i[0]], lo128(tmp0));\n _mm_storeu_pd(&data[i[1]], lo128(tmp1));\n _mm_storeu_pd(&data[i[2]], hi128(tmp0));\n _mm_storeu_pd(&data[i[3]], hi128(tmp1));\n }\n template // interleave 3 args{{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2)\n {\n using namespace AVX;\n#ifdef Vc_USE_MASKMOV_SCATTER\n const m256d tmp0 = _mm256_unpacklo_pd(v0.data(), v1.data());\n const m256d tmp1 = _mm256_unpackhi_pd(v0.data(), v1.data());\n const m256d tmp2 = _mm256_unpacklo_pd(v2.data(), v2.data());\n const m256d tmp3 = _mm256_unpackhi_pd(v2.data(), v2.data());\n\n#if defined(Vc_MSVC) && (Vc_MSVC < 170000000 || !defined(_WIN64))\n // MSVC needs to be at Version 2012 before _mm256_set_epi64x works\n const m256i mask = concat(_mm_setallone_si128(), _mm_set_epi32(0, 0, -1, -1));\n#else\n const m256i mask = _mm256_set_epi64x(0, -1, -1, -1);\n#endif\n _mm256_maskstore_pd(&data[i[0]], mask, Mem::shuffle128(tmp0, tmp2));\n _mm256_maskstore_pd(&data[i[1]], mask, Mem::shuffle128(tmp1, tmp3));\n _mm256_maskstore_pd(&data[i[2]], mask, Mem::shuffle128(tmp0, tmp2));\n _mm256_maskstore_pd(&data[i[3]], mask, Mem::shuffle128(tmp1, tmp3));\n#else\n interleave(data, i, v0, v1);\n v2.scatter(data + 2, i);\n#endif\n }\n template // interleave 4 args{{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3)\n {\n using namespace AVX;\n // 0a 1a 0c 1c:\n const m256d tmp0 = _mm256_unpacklo_pd(v0.data(), v1.data());\n // 0b 1b 0b 1b:\n const m256d tmp1 = _mm256_unpackhi_pd(v0.data(), v1.data());\n // 2a 3a 2c 3c:\n const m256d tmp2 = _mm256_unpacklo_pd(v2.data(), v3.data());\n // 2b 3b 2b 3b:\n const m256d tmp3 = _mm256_unpackhi_pd(v2.data(), v3.data());\n /* The following might be more efficient once 256-bit stores are not split internally into 2\n * 128-bit stores.\n _mm256_storeu_pd(&data[i[0]], Mem::shuffle128(tmp0, tmp2));\n _mm256_storeu_pd(&data[i[1]], Mem::shuffle128(tmp1, tmp3));\n _mm256_storeu_pd(&data[i[2]], Mem::shuffle128(tmp0, tmp2));\n _mm256_storeu_pd(&data[i[3]], Mem::shuffle128(tmp1, tmp3));\n */\n _mm_storeu_pd(&data[i[0] ], lo128(tmp0));\n _mm_storeu_pd(&data[i[0]+2], lo128(tmp2));\n _mm_storeu_pd(&data[i[1] ], lo128(tmp1));\n _mm_storeu_pd(&data[i[1]+2], lo128(tmp3));\n _mm_storeu_pd(&data[i[2] ], hi128(tmp0));\n _mm_storeu_pd(&data[i[2]+2], hi128(tmp2));\n _mm_storeu_pd(&data[i[3] ], hi128(tmp1));\n _mm_storeu_pd(&data[i[3]+2], hi128(tmp3));\n }\n template // interleave 5 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4)\n {\n interleave(data, i, v0, v1, v2, v3);\n v4.scatter(data + 4, i);\n }\n template // interleave 6 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4, const typename V::AsArg v5)\n {\n interleave(data, i, v0, v1, v2, v3);\n interleave(data + 4, i, v4, v5);\n }\n template // interleave 7 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4, const typename V::AsArg v5,\n const typename V::AsArg v6)\n {\n interleave(data, i, v0, v1, v2, v3);\n interleave(data + 4, i, v4, v5, v6);\n }\n template // interleave 8 args {{{2\n static inline void interleave(typename V::EntryType *const data, const I &i,\n const typename V::AsArg v0, const typename V::AsArg v1,\n const typename V::AsArg v2, const typename V::AsArg v3,\n const typename V::AsArg v4, const typename V::AsArg v5,\n const typename V::AsArg v6, const typename V::AsArg v7)\n {\n interleave(data, i, v0, v1, v2, v3);\n interleave(data + 4, i, v4, v5, v6, v7);\n }\n //}}}2\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1)\n {\n using namespace Vc::AVX;\n const m256d ab02 = concat(_mm_loadu_pd(&data[i[0]]), _mm_loadu_pd(&data[i[2]]));\n const m256d ab13 = concat(_mm_loadu_pd(&data[i[1]]), _mm_loadu_pd(&data[i[3]]));\n\n v0.data() = _mm256_unpacklo_pd(ab02, ab13);\n v1.data() = _mm256_unpackhi_pd(ab02, ab13);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2)\n {\n v2.gather(data + 2, i);\n deinterleave(data, i, v0, v1);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3)\n {\n deinterleave(data, i, v0, v1);\n deinterleave(data + 2, i, v2, v3);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4)\n {\n v4.gather(data + 4, i);\n deinterleave(data, i, v0, v1);\n deinterleave(data + 2, i, v2, v3);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5)\n {\n deinterleave(data, i, v0, v1);\n deinterleave(data + 2, i, v2, v3);\n deinterleave(data + 4, i, v4, v5);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6)\n {\n v6.gather(data + 6, i);\n deinterleave(data, i, v0, v1);\n deinterleave(data + 2, i, v2, v3);\n deinterleave(data + 4, i, v4, v5);\n }/*}}}*/\n template static inline void deinterleave(typename V::EntryType const *const data,/*{{{*/\n const I &i, V &v0, V &v1, V &v2, V &v3, V &v4, V &v5, V &v6, V &v7)\n {\n deinterleave(data, i, v0, v1);\n deinterleave(data + 2, i, v2, v3);\n deinterleave(data + 4, i, v4, v5);\n deinterleave(data + 6, i, v6, v7);\n }/*}}}*/\n};\n//}}}1\n} // namespace Detail\n} // namespace Vc\n\n#endif // VC_AVX_DETAIL_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/avx/helperimpl.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2011-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_HELPERIMPL_H_\n#define VC_AVX_HELPERIMPL_H_\n\n#include \"../sse/helperimpl.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Detail\n{\ntemplate \ninline void deinterleave(AVX2::float_v &, AVX2::float_v &, const float *, A);\ntemplate \ninline void deinterleave(AVX2::float_v &, AVX2::float_v &, const short *, A);\ntemplate \ninline void deinterleave(AVX2::float_v &, AVX2::float_v &, const ushort *, A);\ntemplate \ninline void deinterleave(AVX2::double_v &, AVX2::double_v &, const double *, A);\ntemplate \ninline void deinterleave(AVX2::int_v &, AVX2::int_v &, const int *, A);\ntemplate \ninline void deinterleave(AVX2::int_v &, AVX2::int_v &, const short *, A);\ntemplate \ninline void deinterleave(AVX2::uint_v &, AVX2::uint_v &, const uint *, A);\ntemplate \ninline void deinterleave(AVX2::uint_v &, AVX2::uint_v &, const ushort *, A);\ntemplate \ninline void deinterleave(AVX2::short_v &, AVX2::short_v &, const short *, A);\ntemplate \ninline void deinterleave(AVX2::ushort_v &, AVX2::ushort_v &, const ushort *, A);\n\ntemplate \nVc_ALWAYS_INLINE_L void deinterleave(AVX2::Vector &Vc_RESTRICT a,\n AVX2::Vector &Vc_RESTRICT b,\n AVX2::Vector &Vc_RESTRICT c,\n const M *Vc_RESTRICT memory,\n A align) Vc_ALWAYS_INLINE_R;\ntemplate \nVc_ALWAYS_INLINE_L void deinterleave(AVX2::Vector &Vc_RESTRICT a,\n AVX2::Vector &Vc_RESTRICT b,\n AVX2::Vector &Vc_RESTRICT c,\n AVX2::Vector &Vc_RESTRICT d,\n const M *Vc_RESTRICT memory,\n A align) Vc_ALWAYS_INLINE_R;\ntemplate \nVc_ALWAYS_INLINE_L void deinterleave(AVX2::Vector &Vc_RESTRICT a,\n AVX2::Vector &Vc_RESTRICT b,\n AVX2::Vector &Vc_RESTRICT c,\n AVX2::Vector &Vc_RESTRICT d,\n AVX2::Vector &Vc_RESTRICT e,\n const M *Vc_RESTRICT memory,\n A align) Vc_ALWAYS_INLINE_R;\ntemplate \nVc_ALWAYS_INLINE_L void deinterleave(\n AVX2::Vector &Vc_RESTRICT a, AVX2::Vector &Vc_RESTRICT b,\n AVX2::Vector &Vc_RESTRICT c, AVX2::Vector &Vc_RESTRICT d,\n AVX2::Vector &Vc_RESTRICT e, AVX2::Vector &Vc_RESTRICT f,\n const M *Vc_RESTRICT memory, A align) Vc_ALWAYS_INLINE_R;\ntemplate \nVc_ALWAYS_INLINE_L void deinterleave(\n AVX2::Vector &Vc_RESTRICT a, AVX2::Vector &Vc_RESTRICT b,\n AVX2::Vector &Vc_RESTRICT c, AVX2::Vector &Vc_RESTRICT d,\n AVX2::Vector &Vc_RESTRICT e, AVX2::Vector &Vc_RESTRICT f,\n AVX2::Vector &Vc_RESTRICT g, AVX2::Vector &Vc_RESTRICT h,\n const M *Vc_RESTRICT memory, A align) Vc_ALWAYS_INLINE_R;\n\nVc_ALWAYS_INLINE void prefetchForOneRead(const void *addr, VectorAbi::Avx)\n{\n prefetchForOneRead(addr, VectorAbi::Sse());\n}\nVc_ALWAYS_INLINE void prefetchForModify(const void *addr, VectorAbi::Avx)\n{\n prefetchForModify(addr, VectorAbi::Sse());\n}\nVc_ALWAYS_INLINE void prefetchClose(const void *addr, VectorAbi::Avx)\n{\n prefetchClose(addr, VectorAbi::Sse());\n}\nVc_ALWAYS_INLINE void prefetchMid(const void *addr, VectorAbi::Avx)\n{\n prefetchMid(addr, VectorAbi::Sse());\n}\nVc_ALWAYS_INLINE void prefetchFar(const void *addr, VectorAbi::Avx)\n{\n prefetchFar(addr, VectorAbi::Sse());\n}\n} // namespace Detail\n} // namespace Vc\n\n#include \"deinterleave.tcc\"\n\n#endif // VC_AVX_HELPERIMPL_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/intrinsics.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_INTRINSICS_H_\n#define VC_AVX_INTRINSICS_H_\n\n#include \"../global.h\"\n#include \"../traits/type_traits.h\"\n\n// see comment in sse/intrinsics.h\nextern \"C\" {\n// AVX\n#include \n\n#if (defined(Vc_IMPL_XOP) || defined(Vc_IMPL_FMA4)) && !defined(Vc_MSVC)\n#include \n#endif\n}\n\n#include \"../common/fix_clang_emmintrin.h\"\n\n#include \"const_data.h\"\n#include \"../common/types.h\"\n#include \"macros.h\"\n#include \n\n#if (defined Vc_CLANG && Vc_CLANG >= 0x30900 && Vc_CLANG < 0x70000)\n#ifdef _mm256_permute2f128_si256\n#undef _mm256_permute2f128_si256\n#define _mm256_permute2f128_si256(V1, V2, M) __extension__ ({ \\\n (__m256i)__builtin_ia32_vperm2f128_si256((__v8si)(__m256i)(V1), \\\n (__v8si)(__m256i)(V2), (char)(M)); })\n#endif\n\n#ifdef _mm256_permute2f128_ps\n#undef _mm256_permute2f128_ps\n#define _mm256_permute2f128_ps(V1, V2, M) __extension__ ({ \\\n (__m256)__builtin_ia32_vperm2f128_ps256((__v8sf)(__m256)(V1), \\\n (__v8sf)(__m256)(V2), (char)(M)); })\n#endif\n\n#ifdef _mm256_permute2x128_si256\n#undef _mm256_permute2x128_si256\n#define _mm256_permute2x128_si256(V1, V2, M) __extension__ ({ \\\n (__m256i)__builtin_ia32_permti256((__m256i)(V1), (__m256i)(V2), (char)(M)); })\n#endif\n#endif\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AvxIntrinsics\n{\n using AVX::c_general;\n using AVX::_IndexesFromZero32;\n using AVX::_IndexesFromZero16;\n using AVX::_IndexesFromZero8;\n\n typedef __m128 m128 ;\n typedef __m128d m128d;\n typedef __m128i m128i;\n typedef __m256 m256 ;\n typedef __m256d m256d;\n typedef __m256i m256i;\n\n#ifdef Vc_GCC\n // Redefine the mul/add/sub intrinsics to use GCC-specific operators instead of builtin\n // functions. This way the fp-contraction optimization step kicks in and creates FMAs! :)\n static Vc_INTRINSIC Vc_CONST m256d _mm256_mul_pd(m256d a, m256d b) { return static_cast(static_cast<__v4df>(a) * static_cast<__v4df>(b)); }\n static Vc_INTRINSIC Vc_CONST m256d _mm256_add_pd(m256d a, m256d b) { return static_cast(static_cast<__v4df>(a) + static_cast<__v4df>(b)); }\n static Vc_INTRINSIC Vc_CONST m256d _mm256_sub_pd(m256d a, m256d b) { return static_cast(static_cast<__v4df>(a) - static_cast<__v4df>(b)); }\n static Vc_INTRINSIC Vc_CONST m256 _mm256_mul_ps(m256 a, m256 b) { return static_cast(static_cast<__v8sf>(a) * static_cast<__v8sf>(b)); }\n static Vc_INTRINSIC Vc_CONST m256 _mm256_add_ps(m256 a, m256 b) { return static_cast(static_cast<__v8sf>(a) + static_cast<__v8sf>(b)); }\n static Vc_INTRINSIC Vc_CONST m256 _mm256_sub_ps(m256 a, m256 b) { return static_cast(static_cast<__v8sf>(a) - static_cast<__v8sf>(b)); }\n#endif\n\n static Vc_INTRINSIC m256d Vc_CONST set1_pd (double a) { return _mm256_set1_pd (a); }\n static Vc_INTRINSIC m256i Vc_CONST set1_epi32(int a) { return _mm256_set1_epi32(a); }\n\n static Vc_INTRINSIC Vc_CONST m128i _mm_setallone_si128() { return _mm_load_si128(reinterpret_cast(Common::AllBitsSet)); }\n static Vc_INTRINSIC Vc_CONST m128 _mm_setallone_ps() { return _mm_load_ps(reinterpret_cast(Common::AllBitsSet)); }\n static Vc_INTRINSIC Vc_CONST m128d _mm_setallone_pd() { return _mm_load_pd(reinterpret_cast(Common::AllBitsSet)); }\n\n static Vc_INTRINSIC Vc_CONST m256i setallone_si256() { return _mm256_castps_si256(_mm256_load_ps(reinterpret_cast(Common::AllBitsSet))); }\n static Vc_INTRINSIC Vc_CONST m256d setallone_pd() { return _mm256_load_pd(reinterpret_cast(Common::AllBitsSet)); }\n static Vc_INTRINSIC Vc_CONST m256 setallone_ps() { return _mm256_load_ps(reinterpret_cast(Common::AllBitsSet)); }\n\n static Vc_INTRINSIC m256i Vc_CONST setone_epi8 () { return _mm256_set1_epi8(1); }\n static Vc_INTRINSIC m256i Vc_CONST setone_epu8 () { return setone_epi8(); }\n static Vc_INTRINSIC m256i Vc_CONST setone_epi16() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast(c_general::one16))); }\n static Vc_INTRINSIC m256i Vc_CONST setone_epu16() { return setone_epi16(); }\n static Vc_INTRINSIC m256i Vc_CONST setone_epi32() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast(&_IndexesFromZero32[1]))); }\n static Vc_INTRINSIC m256i Vc_CONST setone_epu32() { return setone_epi32(); }\n\n static Vc_INTRINSIC m256 Vc_CONST setone_ps() { return _mm256_broadcast_ss(&c_general::oneFloat); }\n static Vc_INTRINSIC m256d Vc_CONST setone_pd() { return _mm256_broadcast_sd(&c_general::oneDouble); }\n\n static Vc_INTRINSIC m256d Vc_CONST setabsmask_pd() { return _mm256_broadcast_sd(reinterpret_cast(&c_general::absMaskFloat[0])); }\n static Vc_INTRINSIC m256 Vc_CONST setabsmask_ps() { return _mm256_broadcast_ss(reinterpret_cast(&c_general::absMaskFloat[1])); }\n static Vc_INTRINSIC m256d Vc_CONST setsignmask_pd(){ return _mm256_broadcast_sd(reinterpret_cast(&c_general::signMaskFloat[0])); }\n static Vc_INTRINSIC m256 Vc_CONST setsignmask_ps(){ return _mm256_broadcast_ss(reinterpret_cast(&c_general::signMaskFloat[1])); }\n\n static Vc_INTRINSIC m256 Vc_CONST set2power31_ps() { return _mm256_broadcast_ss(&c_general::_2power31); }\n static Vc_INTRINSIC m128 Vc_CONST _mm_set2power31_ps() { return _mm_broadcast_ss(&c_general::_2power31); }\n static Vc_INTRINSIC m256i Vc_CONST set2power31_epu32() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast(&c_general::signMaskFloat[1]))); }\n static Vc_INTRINSIC m128i Vc_CONST _mm_set2power31_epu32() { return _mm_castps_si128(_mm_broadcast_ss(reinterpret_cast(&c_general::signMaskFloat[1]))); }\n\n static Vc_INTRINSIC m256i Vc_CONST setmin_epi8 () { return _mm256_set1_epi8(-0x80); }\n static Vc_INTRINSIC m128i Vc_CONST _mm_setmin_epi16() { return _mm_castps_si128(_mm_broadcast_ss(reinterpret_cast(c_general::minShort))); }\n static Vc_INTRINSIC m128i Vc_CONST _mm_setmin_epi32() { return _mm_castps_si128(_mm_broadcast_ss(reinterpret_cast(&c_general::signMaskFloat[1]))); }\n static Vc_INTRINSIC m256i Vc_CONST setmin_epi16() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast(c_general::minShort))); }\n static Vc_INTRINSIC m256i Vc_CONST setmin_epi32() { return _mm256_castps_si256(_mm256_broadcast_ss(reinterpret_cast(&c_general::signMaskFloat[1]))); }\n\n template \n static Vc_INTRINSIC Vc_CONST unsigned int extract_epu32(__m128i x)\n {\n return _mm_extract_epi32(x, i);\n }\n\n template Vc_INTRINSIC __m256 insert128(__m256 a, __m128 b) { return _mm256_insertf128_ps(a, b, offset); }\n template Vc_INTRINSIC __m256d insert128(__m256d a, __m128d b) { return _mm256_insertf128_pd(a, b, offset); }\n template Vc_INTRINSIC __m256i insert128(__m256i a, __m128i b) {\n#ifdef Vc_IMPL_AVX2\n return _mm256_inserti128_si256(a, b, offset);\n#else\n return _mm256_insertf128_si256(a, b, offset);\n#endif\n }\n\n template Vc_INTRINSIC __m128 extract128(__m256 a) { return _mm256_extractf128_ps(a, offset); }\n template Vc_INTRINSIC __m128d extract128(__m256d a) { return _mm256_extractf128_pd(a, offset); }\n template Vc_INTRINSIC __m128i extract128(__m256i a) {\n#ifdef Vc_IMPL_AVX2\n return _mm256_extracti128_si256(a, offset);\n#else\n return _mm256_extractf128_si256(a, offset);\n#endif\n }\n\n /////////////////////// COMPARE OPS ///////////////////////\n#ifdef Vc_GCC\n // GCC needs builtin compare operators to enable constant folding\n Vc_INTRINSIC __m256d cmpeq_pd (__m256d a, __m256d b) { return reinterpret_cast<__m256d>(a == b); }\n Vc_INTRINSIC __m256d cmpneq_pd (__m256d a, __m256d b) { return reinterpret_cast<__m256d>(a != b); }\n Vc_INTRINSIC __m256d cmplt_pd (__m256d a, __m256d b) { return reinterpret_cast<__m256d>(a < b); }\n Vc_INTRINSIC __m256d cmpge_pd (__m256d a, __m256d b) { return reinterpret_cast<__m256d>(a >= b); }\n Vc_INTRINSIC __m256d cmple_pd (__m256d a, __m256d b) { return reinterpret_cast<__m256d>(a <= b); }\n Vc_INTRINSIC __m256d cmpgt_pd (__m256d a, __m256d b) { return reinterpret_cast<__m256d>(a > b); }\n\n Vc_INTRINSIC __m256 cmpeq_ps (__m256 a, __m256 b) { return reinterpret_cast<__m256 >(a == b); }\n Vc_INTRINSIC __m256 cmpneq_ps (__m256 a, __m256 b) { return reinterpret_cast<__m256 >(a != b); }\n Vc_INTRINSIC __m256 cmplt_ps (__m256 a, __m256 b) { return reinterpret_cast<__m256 >(a < b); }\n Vc_INTRINSIC __m256 cmpge_ps (__m256 a, __m256 b) { return reinterpret_cast<__m256 >(a >= b); }\n Vc_INTRINSIC __m256 cmple_ps (__m256 a, __m256 b) { return reinterpret_cast<__m256 >(a <= b); }\n Vc_INTRINSIC __m256 cmpgt_ps (__m256 a, __m256 b) { return reinterpret_cast<__m256 >(a > b); }\n#else\n Vc_INTRINSIC __m256d cmpeq_pd (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_EQ_OQ); }\n Vc_INTRINSIC __m256d cmpneq_pd (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_NEQ_UQ); }\n Vc_INTRINSIC __m256d cmplt_pd (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_LT_OS); }\n Vc_INTRINSIC __m256d cmpge_pd (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_NLT_US); }\n Vc_INTRINSIC __m256d cmple_pd (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_LE_OS); }\n Vc_INTRINSIC __m256d cmpgt_pd (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_NLE_US); }\n\n Vc_INTRINSIC __m256 cmpeq_ps (__m256 a, __m256 b) { return _mm256_cmp_ps(a, b, _CMP_EQ_OQ); }\n Vc_INTRINSIC __m256 cmpneq_ps (__m256 a, __m256 b) { return _mm256_cmp_ps(a, b, _CMP_NEQ_UQ); }\n Vc_INTRINSIC __m256 cmplt_ps (__m256 a, __m256 b) { return _mm256_cmp_ps(a, b, _CMP_LT_OS); }\n Vc_INTRINSIC __m256 cmpge_ps (__m256 a, __m256 b) { return _mm256_cmp_ps(a, b, _CMP_NLT_US); }\n Vc_INTRINSIC __m256 cmple_ps (__m256 a, __m256 b) { return _mm256_cmp_ps(a, b, _CMP_LE_OS); }\n Vc_INTRINSIC __m256 cmpgt_ps (__m256 a, __m256 b) { return _mm256_cmp_ps(a, b, _CMP_NLE_US); }\n#endif\n Vc_INTRINSIC __m256d cmpnlt_pd (__m256d a, __m256d b) { return cmpge_pd(a, b); }\n Vc_INTRINSIC __m256d cmpnle_pd (__m256d a, __m256d b) { return cmpgt_pd(a, b); }\n Vc_INTRINSIC __m256 cmpnlt_ps (__m256 a, __m256 b) { return cmpge_ps(a, b); }\n Vc_INTRINSIC __m256 cmpnle_ps (__m256 a, __m256 b) { return cmpgt_ps(a, b); }\n\n Vc_INTRINSIC __m256d cmpord_pd (__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_ORD_Q); }\n Vc_INTRINSIC __m256d cmpunord_pd(__m256d a, __m256d b) { return _mm256_cmp_pd(a, b, _CMP_UNORD_Q); }\n Vc_INTRINSIC __m256 cmpord_ps (__m256 a, __m256 b) { return _mm256_cmp_ps(a, b, _CMP_ORD_Q); }\n Vc_INTRINSIC __m256 cmpunord_ps(__m256 a, __m256 b) { return _mm256_cmp_ps(a, b, _CMP_UNORD_Q); }\n\n#if defined(Vc_IMPL_XOP)\n static Vc_INTRINSIC m128i cmplt_epu16(__m128i a, __m128i b) {\n return _mm_comlt_epu16(a, b);\n }\n static Vc_INTRINSIC m128i cmpgt_epu16(__m128i a, __m128i b) {\n return _mm_comgt_epu16(a, b);\n }\n#else\n static Vc_INTRINSIC m128i cmplt_epu16(__m128i a, __m128i b) {\n return _mm_cmplt_epi16(_mm_xor_si128(a, _mm_setmin_epi16()), _mm_xor_si128(b, _mm_setmin_epi16()));\n }\n static Vc_INTRINSIC m128i cmpgt_epu16(__m128i a, __m128i b) {\n return _mm_cmpgt_epi16(_mm_xor_si128(a, _mm_setmin_epi16()), _mm_xor_si128(b, _mm_setmin_epi16()));\n }\n#endif\n\n#ifdef Vc_IMPL_AVX2\n template Vc_INTRINSIC Vc_CONST m256i alignr(__m256i s1, __m256i s2)\n {\n return _mm256_alignr_epi8(s1, s2, shift);\n }\n#else\n template Vc_INTRINSIC Vc_CONST m256i alignr(__m256i s1, __m256i s2)\n {\n return insert128<1>(\n _mm256_castsi128_si256(_mm_alignr_epi8(_mm256_castsi256_si128(s1),\n _mm256_castsi256_si128(s2), shift)),\n _mm_alignr_epi8(extract128<1>(s1), extract128<1>(s2), shift));\n }\n#endif\n\n#ifdef Vc_IMPL_AVX2\n#define Vc_AVX_TO_SSE_2_NEW(name) \\\n Vc_INTRINSIC Vc_CONST m256i name(__m256i a0, __m256i b0) \\\n { \\\n return _mm256_##name(a0, b0); \\\n }\n#define Vc_AVX_TO_SSE_256_128(name) \\\n Vc_INTRINSIC Vc_CONST m256i name(__m256i a0, __m128i b0) \\\n { \\\n return _mm256_##name(a0, b0); \\\n }\n#define Vc_AVX_TO_SSE_1i(name) \\\n template Vc_INTRINSIC Vc_CONST m256i name(__m256i a0) \\\n { \\\n return _mm256_##name(a0, i); \\\n }\n#define Vc_AVX_TO_SSE_1(name) \\\n Vc_INTRINSIC Vc_CONST __m256i name(__m256i a0) { return _mm256_##name(a0); }\n#define Vc_AVX_TO_SSE_1_128(name, shift__) \\\n Vc_INTRINSIC Vc_CONST __m256i name(__m128i a0) { return _mm256_##name(a0); }\n#else\n/**\\internal\n * Defines the function \\p name, which takes to __m256i arguments and calls `_mm_##name` on the low\n * and high 128 bit halfs of the arguments.\n *\n * In case the AVX2 intrinsics are enabled, the arguments are directly passed to a single\n * `_mm256_##name` call.\n */\n#define Vc_AVX_TO_SSE_1(name) \\\n Vc_INTRINSIC Vc_CONST __m256i name(__m256i a0) \\\n { \\\n __m128i a1 = extract128<1>(a0); \\\n __m128i r0 = _mm_##name(_mm256_castsi256_si128(a0)); \\\n __m128i r1 = _mm_##name(a1); \\\n return insert128<1>(_mm256_castsi128_si256(r0), r1); \\\n }\n#define Vc_AVX_TO_SSE_1_128(name, shift__) \\\n Vc_INTRINSIC Vc_CONST __m256i name(__m128i a0) \\\n { \\\n __m128i r0 = _mm_##name(a0); \\\n __m128i r1 = _mm_##name(_mm_srli_si128(a0, shift__)); \\\n return insert128<1>(_mm256_castsi128_si256(r0), r1); \\\n }\n#define Vc_AVX_TO_SSE_2_NEW(name) \\\n Vc_INTRINSIC Vc_CONST m256i name(__m256i a0, __m256i b0) \\\n { \\\n m128i a1 = extract128<1>(a0); \\\n m128i b1 = extract128<1>(b0); \\\n m128i r0 = _mm_##name(_mm256_castsi256_si128(a0), _mm256_castsi256_si128(b0)); \\\n m128i r1 = _mm_##name(a1, b1); \\\n return insert128<1>(_mm256_castsi128_si256(r0), r1); \\\n }\n#define Vc_AVX_TO_SSE_256_128(name) \\\n Vc_INTRINSIC Vc_CONST m256i name(__m256i a0, __m128i b0) \\\n { \\\n m128i a1 = extract128<1>(a0); \\\n m128i r0 = _mm_##name(_mm256_castsi256_si128(a0), b0); \\\n m128i r1 = _mm_##name(a1, b0); \\\n return insert128<1>(_mm256_castsi128_si256(r0), r1); \\\n }\n#define Vc_AVX_TO_SSE_1i(name) \\\n template Vc_INTRINSIC Vc_CONST m256i name(__m256i a0) \\\n { \\\n m128i a1 = extract128<1>(a0); \\\n m128i r0 = _mm_##name(_mm256_castsi256_si128(a0), i); \\\n m128i r1 = _mm_##name(a1, i); \\\n return insert128<1>(_mm256_castsi128_si256(r0), r1); \\\n }\n#endif\n Vc_INTRINSIC Vc_CONST __m128i sll_epi16(__m128i a, __m128i b) { return _mm_sll_epi16(a, b); }\n Vc_INTRINSIC Vc_CONST __m128i sll_epi32(__m128i a, __m128i b) { return _mm_sll_epi32(a, b); }\n Vc_INTRINSIC Vc_CONST __m128i sll_epi64(__m128i a, __m128i b) { return _mm_sll_epi64(a, b); }\n Vc_INTRINSIC Vc_CONST __m128i srl_epi16(__m128i a, __m128i b) { return _mm_srl_epi16(a, b); }\n Vc_INTRINSIC Vc_CONST __m128i srl_epi32(__m128i a, __m128i b) { return _mm_srl_epi32(a, b); }\n Vc_INTRINSIC Vc_CONST __m128i srl_epi64(__m128i a, __m128i b) { return _mm_srl_epi64(a, b); }\n Vc_INTRINSIC Vc_CONST __m128i sra_epi16(__m128i a, __m128i b) { return _mm_sra_epi16(a, b); }\n Vc_INTRINSIC Vc_CONST __m128i sra_epi32(__m128i a, __m128i b) { return _mm_sra_epi32(a, b); }\n\n Vc_AVX_TO_SSE_1i(slli_epi16)\n Vc_AVX_TO_SSE_1i(slli_epi32)\n Vc_AVX_TO_SSE_1i(slli_epi64)\n Vc_AVX_TO_SSE_1i(srai_epi16)\n Vc_AVX_TO_SSE_1i(srai_epi32)\n Vc_AVX_TO_SSE_1i(srli_epi16)\n Vc_AVX_TO_SSE_1i(srli_epi32)\n Vc_AVX_TO_SSE_1i(srli_epi64)\n\n Vc_AVX_TO_SSE_256_128(sll_epi16)\n Vc_AVX_TO_SSE_256_128(sll_epi32)\n Vc_AVX_TO_SSE_256_128(sll_epi64)\n Vc_AVX_TO_SSE_256_128(srl_epi16)\n Vc_AVX_TO_SSE_256_128(srl_epi32)\n Vc_AVX_TO_SSE_256_128(srl_epi64)\n Vc_AVX_TO_SSE_256_128(sra_epi16)\n Vc_AVX_TO_SSE_256_128(sra_epi32)\n\n Vc_AVX_TO_SSE_2_NEW(cmpeq_epi8)\n Vc_AVX_TO_SSE_2_NEW(cmpeq_epi16)\n Vc_AVX_TO_SSE_2_NEW(cmpeq_epi32)\n Vc_AVX_TO_SSE_2_NEW(cmpeq_epi64)\n Vc_AVX_TO_SSE_2_NEW(cmpgt_epi8)\n Vc_AVX_TO_SSE_2_NEW(cmpgt_epi16)\n Vc_AVX_TO_SSE_2_NEW(cmpgt_epi32)\n Vc_AVX_TO_SSE_2_NEW(cmpgt_epi64)\n Vc_AVX_TO_SSE_2_NEW(unpackhi_epi16)\n Vc_AVX_TO_SSE_2_NEW(unpacklo_epi16)\n Vc_AVX_TO_SSE_2_NEW(add_epi16)\n Vc_AVX_TO_SSE_2_NEW(add_epi32)\n Vc_AVX_TO_SSE_2_NEW(add_epi64)\n Vc_AVX_TO_SSE_2_NEW(sub_epi16)\n Vc_AVX_TO_SSE_2_NEW(sub_epi32)\n Vc_AVX_TO_SSE_2_NEW(mullo_epi16)\n Vc_AVX_TO_SSE_2_NEW(sign_epi16)\n Vc_AVX_TO_SSE_2_NEW(sign_epi32)\n Vc_AVX_TO_SSE_2_NEW(min_epi8)\n Vc_AVX_TO_SSE_2_NEW(max_epi8)\n Vc_AVX_TO_SSE_2_NEW(min_epu16)\n Vc_AVX_TO_SSE_2_NEW(max_epu16)\n Vc_AVX_TO_SSE_2_NEW(min_epi32)\n Vc_AVX_TO_SSE_2_NEW(max_epi32)\n Vc_AVX_TO_SSE_2_NEW(min_epu32)\n Vc_AVX_TO_SSE_2_NEW(max_epu32)\n Vc_AVX_TO_SSE_2_NEW(mullo_epi32)\n\n Vc_AVX_TO_SSE_1(abs_epi8)\n Vc_AVX_TO_SSE_1(abs_epi16)\n Vc_AVX_TO_SSE_1(abs_epi32)\n Vc_AVX_TO_SSE_1_128(cvtepi8_epi16, 8)\n Vc_AVX_TO_SSE_1_128(cvtepi8_epi32, 4)\n Vc_AVX_TO_SSE_1_128(cvtepi8_epi64, 2)\n Vc_AVX_TO_SSE_1_128(cvtepi16_epi32, 8)\n Vc_AVX_TO_SSE_1_128(cvtepi16_epi64, 4)\n Vc_AVX_TO_SSE_1_128(cvtepi32_epi64, 8)\n Vc_AVX_TO_SSE_1_128(cvtepu8_epi16, 8)\n Vc_AVX_TO_SSE_1_128(cvtepu8_epi32, 4)\n Vc_AVX_TO_SSE_1_128(cvtepu8_epi64, 2)\n Vc_AVX_TO_SSE_1_128(cvtepu16_epi32, 8)\n Vc_AVX_TO_SSE_1_128(cvtepu16_epi64, 4)\n Vc_AVX_TO_SSE_1_128(cvtepu32_epi64, 8)\n#ifndef Vc_IMPL_AVX2\n\n/////////////////////////////////////////////////////////////////////////\n// implementation of the intrinsics missing in AVX\n/////////////////////////////////////////////////////////////////////////\n\n static Vc_INTRINSIC m256i Vc_CONST and_si256(__m256i x, __m256i y) {\n return _mm256_castps_si256(_mm256_and_ps(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));\n }\n static Vc_INTRINSIC m256i Vc_CONST andnot_si256(__m256i x, __m256i y) {\n return _mm256_castps_si256(_mm256_andnot_ps(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));\n }\n static Vc_INTRINSIC m256i Vc_CONST or_si256(__m256i x, __m256i y) {\n return _mm256_castps_si256(_mm256_or_ps(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));\n }\n static Vc_INTRINSIC m256i Vc_CONST xor_si256(__m256i x, __m256i y) {\n return _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));\n }\n\n Vc_INTRINSIC Vc_CONST int movemask_epi8(__m256i a0)\n {\n m128i a1 = extract128<1>(a0);\n return (_mm_movemask_epi8(a1) << 16) | _mm_movemask_epi8(_mm256_castsi256_si128(a0));\n }\n template Vc_INTRINSIC Vc_CONST m256i blend_epi16(__m256i a0, __m256i b0)\n {\n m128i a1 = extract128<1>(a0);\n m128i b1 = extract128<1>(b0);\n m128i r0 = _mm_blend_epi16(_mm256_castsi256_si128(a0), _mm256_castsi256_si128(b0), m & 0xff);\n m128i r1 = _mm_blend_epi16(a1, b1, m >> 8);\n return insert128<1>(_mm256_castsi128_si256(r0), r1);\n }\n Vc_INTRINSIC Vc_CONST m256i blendv_epi8(__m256i a0, __m256i b0, __m256i m0) {\n m128i a1 = extract128<1>(a0);\n m128i b1 = extract128<1>(b0);\n m128i m1 = extract128<1>(m0);\n m128i r0 = _mm_blendv_epi8(_mm256_castsi256_si128(a0), _mm256_castsi256_si128(b0), _mm256_castsi256_si128(m0));\n m128i r1 = _mm_blendv_epi8(a1, b1, m1);\n return insert128<1>(_mm256_castsi128_si256(r0), r1);\n }\n // mpsadbw_epu8 (__m128i __X, __m128i __Y, const int __M)\n\n#else // Vc_IMPL_AVX2\n\nstatic Vc_INTRINSIC Vc_CONST m256i xor_si256(__m256i x, __m256i y) { return _mm256_xor_si256(x, y); }\nstatic Vc_INTRINSIC Vc_CONST m256i or_si256(__m256i x, __m256i y) { return _mm256_or_si256(x, y); }\nstatic Vc_INTRINSIC Vc_CONST m256i and_si256(__m256i x, __m256i y) { return _mm256_and_si256(x, y); }\nstatic Vc_INTRINSIC Vc_CONST m256i andnot_si256(__m256i x, __m256i y) { return _mm256_andnot_si256(x, y); }\n\n/////////////////////////////////////////////////////////////////////////\n// implementation of the intrinsics missing in AVX2\n/////////////////////////////////////////////////////////////////////////\nVc_INTRINSIC Vc_CONST m256i blendv_epi8(__m256i a0, __m256i b0, __m256i m0)\n{\n return _mm256_blendv_epi8(a0, b0, m0);\n}\nVc_INTRINSIC Vc_CONST int movemask_epi8(__m256i a0)\n{\n return _mm256_movemask_epi8(a0);\n}\n\n#endif // Vc_IMPL_AVX2\n\n/////////////////////////////////////////////////////////////////////////\n// implementation of intrinsics missing in AVX and AVX2\n/////////////////////////////////////////////////////////////////////////\n\nstatic Vc_INTRINSIC m256i cmplt_epi64(__m256i a, __m256i b) {\n return cmpgt_epi64(b, a);\n}\nstatic Vc_INTRINSIC m256i cmplt_epi32(__m256i a, __m256i b) {\n return cmpgt_epi32(b, a);\n}\nstatic Vc_INTRINSIC m256i cmplt_epi16(__m256i a, __m256i b) {\n return cmpgt_epi16(b, a);\n}\nstatic Vc_INTRINSIC m256i cmplt_epi8(__m256i a, __m256i b) {\n return cmpgt_epi8(b, a);\n}\n\nstatic Vc_INTRINSIC m256i cmpgt_epu8(__m256i a, __m256i b) {\n return cmpgt_epi8(xor_si256(a, setmin_epi8()), xor_si256(b, setmin_epi8()));\n}\n#if defined(Vc_IMPL_XOP)\n Vc_AVX_TO_SSE_2_NEW(comlt_epu32)\n Vc_AVX_TO_SSE_2_NEW(comgt_epu32)\n Vc_AVX_TO_SSE_2_NEW(comlt_epu16)\n Vc_AVX_TO_SSE_2_NEW(comgt_epu16)\n static Vc_INTRINSIC m256i Vc_CONST cmplt_epu32(__m256i a, __m256i b) { return comlt_epu32(a, b); }\n static Vc_INTRINSIC m256i Vc_CONST cmpgt_epu32(__m256i a, __m256i b) { return comgt_epu32(a, b); }\n static Vc_INTRINSIC m256i Vc_CONST cmplt_epu16(__m256i a, __m256i b) { return comlt_epu16(a, b); }\n static Vc_INTRINSIC m256i Vc_CONST cmpgt_epu16(__m256i a, __m256i b) { return comgt_epu16(a, b); }\n#else\n static Vc_INTRINSIC m256i Vc_CONST cmplt_epu32(__m256i _a, __m256i _b) {\n m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(setmin_epi32())));\n m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(setmin_epi32())));\n return cmplt_epi32(a, b);\n }\n static Vc_INTRINSIC m256i Vc_CONST cmpgt_epu32(__m256i _a, __m256i _b) {\n m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(setmin_epi32())));\n m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(setmin_epi32())));\n return cmpgt_epi32(a, b);\n }\n static Vc_INTRINSIC m256i Vc_CONST cmplt_epu16(__m256i _a, __m256i _b) {\n m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(setmin_epi16())));\n m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(setmin_epi16())));\n return cmplt_epi16(a, b);\n }\n static Vc_INTRINSIC m256i Vc_CONST cmpgt_epu16(__m256i _a, __m256i _b) {\n m256i a = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_a), _mm256_castsi256_ps(setmin_epi16())));\n m256i b = _mm256_castps_si256(_mm256_xor_ps(_mm256_castsi256_ps(_b), _mm256_castsi256_ps(setmin_epi16())));\n return cmpgt_epi16(a, b);\n }\n#endif\n\nstatic Vc_INTRINSIC void _mm256_maskstore(float *mem, const __m256 mask, const __m256 v) {\n _mm256_maskstore_ps(mem, _mm256_castps_si256(mask), v);\n}\nstatic Vc_INTRINSIC void _mm256_maskstore(double *mem, const __m256d mask, const __m256d v) {\n _mm256_maskstore_pd(mem, _mm256_castpd_si256(mask), v);\n}\nstatic Vc_INTRINSIC void _mm256_maskstore(int *mem, const __m256i mask, const __m256i v) {\n#ifdef Vc_IMPL_AVX2\n _mm256_maskstore_epi32(mem, mask, v);\n#else\n _mm256_maskstore_ps(reinterpret_cast(mem), mask, _mm256_castsi256_ps(v));\n#endif\n}\nstatic Vc_INTRINSIC void _mm256_maskstore(unsigned int *mem, const __m256i mask, const __m256i v) {\n _mm256_maskstore(reinterpret_cast(mem), mask, v);\n}\nstatic Vc_INTRINSIC void _mm256_maskstore(short *mem, const __m256i mask, const __m256i v) {\n using namespace AVX;\n _mm_maskmoveu_si128(_mm256_castsi256_si128(v), _mm256_castsi256_si128(mask), reinterpret_cast(&mem[0]));\n _mm_maskmoveu_si128(extract128<1>(v), extract128<1>(mask), reinterpret_cast(&mem[8]));\n}\nstatic Vc_INTRINSIC void _mm256_maskstore(unsigned short *mem, const __m256i mask, const __m256i v) {\n _mm256_maskstore(reinterpret_cast(mem), mask, v);\n}\n\n#undef Vc_AVX_TO_SSE_1\n#undef Vc_AVX_TO_SSE_1_128\n#undef Vc_AVX_TO_SSE_2_NEW\n#undef Vc_AVX_TO_SSE_256_128\n#undef Vc_AVX_TO_SSE_1i\n\ntemplate Vc_INTRINSIC_L R stream_load(const float *mem) Vc_INTRINSIC_R;\ntemplate<> Vc_INTRINSIC m128 stream_load(const float *mem)\n{\n return _mm_castsi128_ps(_mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast(mem))));\n}\ntemplate<> Vc_INTRINSIC m256 stream_load(const float *mem)\n{\n return insert128<1>(_mm256_castps128_ps256(stream_load(mem)),\n stream_load(mem + 4));\n}\n\ntemplate Vc_INTRINSIC_L R stream_load(const double *mem) Vc_INTRINSIC_R;\ntemplate<> Vc_INTRINSIC m128d stream_load(const double *mem)\n{\n return _mm_castsi128_pd(_mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast(mem))));\n}\ntemplate<> Vc_INTRINSIC m256d stream_load(const double *mem)\n{\n return insert128<1>(_mm256_castpd128_pd256(stream_load(mem)),\n stream_load(mem + 2));\n}\n\ntemplate Vc_INTRINSIC_L R stream_load(const void *mem) Vc_INTRINSIC_R;\ntemplate<> Vc_INTRINSIC m128i stream_load(const void *mem)\n{\n return _mm_stream_load_si128(reinterpret_cast<__m128i *>(const_cast(mem)));\n}\ntemplate<> Vc_INTRINSIC m256i stream_load(const void *mem)\n{\n return insert128<1>(_mm256_castsi128_si256(stream_load(mem)),\n stream_load(static_cast(mem) + 1));\n}\n\nVc_INTRINSIC void stream_store(float *mem, __m128 value, __m128 mask)\n{\n _mm_maskmoveu_si128(_mm_castps_si128(value), _mm_castps_si128(mask), reinterpret_cast(mem));\n}\nVc_INTRINSIC void stream_store(float *mem, __m256 value, __m256 mask)\n{\n stream_store(mem, _mm256_castps256_ps128(value), _mm256_castps256_ps128(mask));\n stream_store(mem + 4, extract128<1>(value), extract128<1>(mask));\n}\nVc_INTRINSIC void stream_store(double *mem, __m128d value, __m128d mask)\n{\n _mm_maskmoveu_si128(_mm_castpd_si128(value), _mm_castpd_si128(mask), reinterpret_cast(mem));\n}\nVc_INTRINSIC void stream_store(double *mem, __m256d value, __m256d mask)\n{\n stream_store(mem, _mm256_castpd256_pd128(value), _mm256_castpd256_pd128(mask));\n stream_store(mem + 2, extract128<1>(value), extract128<1>(mask));\n}\nVc_INTRINSIC void stream_store(void *mem, __m128i value, __m128i mask)\n{\n _mm_maskmoveu_si128(value, mask, reinterpret_cast(mem));\n}\nVc_INTRINSIC void stream_store(void *mem, __m256i value, __m256i mask)\n{\n stream_store(mem, _mm256_castsi256_si128(value), _mm256_castsi256_si128(mask));\n stream_store(static_cast<__m128i *>(mem) + 1, extract128<1>(value), extract128<1>(mask));\n}\n\n#ifndef __x86_64__\nVc_INTRINSIC Vc_PURE __m128i _mm_cvtsi64_si128(int64_t x) {\n return _mm_castpd_si128(_mm_load_sd(reinterpret_cast(&x)));\n}\n#endif\n\n#ifdef Vc_IMPL_AVX2\ntemplate __m256 gather(const float *addr, __m256i idx)\n{\n return _mm256_i32gather_ps(addr, idx, Scale);\n}\ntemplate __m256d gather(const double *addr, __m128i idx)\n{\n return _mm256_i32gather_pd(addr, idx, Scale);\n}\ntemplate __m256i gather(const int *addr, __m256i idx)\n{\n return _mm256_i32gather_epi32(addr, idx, Scale);\n}\ntemplate __m256i gather(const unsigned *addr, __m256i idx)\n{\n return _mm256_i32gather_epi32(aliasing_cast(addr), idx, Scale);\n}\n\ntemplate __m256 gather(__m256 src, __m256 k, const float *addr, __m256i idx)\n{\n return _mm256_mask_i32gather_ps(src, addr, idx, k, Scale);\n}\ntemplate \n__m256d gather(__m256d src, __m256d k, const double *addr, __m128i idx)\n{\n return _mm256_mask_i32gather_pd(src, addr, idx, k, Scale);\n}\ntemplate __m256i gather(__m256i src, __m256i k, const int *addr, __m256i idx)\n{\n return _mm256_mask_i32gather_epi32(src, addr, idx, k, Scale);\n}\ntemplate \n__m256i gather(__m256i src, __m256i k, const unsigned *addr, __m256i idx)\n{\n return _mm256_mask_i32gather_epi32(src, aliasing_cast(addr), idx, k, Scale);\n}\n#endif\n\n} // namespace AvxIntrinsics\n} // namespace Vc\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AVX\n{\n using namespace AvxIntrinsics;\n} // namespace AVX\nnamespace AVX2\n{\n using namespace AvxIntrinsics;\n} // namespace AVX2\nnamespace AVX\n{\n template struct VectorTypeHelper;\n template<> struct VectorTypeHelper< char > { typedef __m256i Type; };\n template<> struct VectorTypeHelper< signed char > { typedef __m256i Type; };\n template<> struct VectorTypeHelper { typedef __m256i Type; };\n template<> struct VectorTypeHelper< short> { typedef __m256i Type; };\n template<> struct VectorTypeHelper { typedef __m256i Type; };\n template<> struct VectorTypeHelper< int > { typedef __m256i Type; };\n template<> struct VectorTypeHelper { typedef __m256i Type; };\n template<> struct VectorTypeHelper< long > { typedef __m256i Type; };\n template<> struct VectorTypeHelper { typedef __m256i Type; };\n template<> struct VectorTypeHelper< long long> { typedef __m256i Type; };\n template<> struct VectorTypeHelper { typedef __m256i Type; };\n template<> struct VectorTypeHelper< float> { typedef __m256 Type; };\n template<> struct VectorTypeHelper< double> { typedef __m256d Type; };\n\n template \n using IntegerVectorType =\n typename std::conditional::type;\n template \n using DoubleVectorType =\n typename std::conditional::type;\n template \n using FloatVectorType =\n typename std::conditional::type;\n\n template struct VectorHelper {};\n template struct VectorHelperSize;\n} // namespace AVX\n} // namespace Vc\n\n#endif // VC_AVX_INTRINSICS_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/limits.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_LIMITS_H_\n#define VC_AVX_LIMITS_H_\n\n#include \"intrinsics.h\"\n#include \"types.h\"\n#include \"macros.h\"\n\nnamespace std\n{\n#define Vc_NUM_LIM(T, _max, _min) \\\n template <> struct numeric_limits> : public numeric_limits { \\\n static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector max() Vc_NOEXCEPT \\\n { \\\n return _max; \\\n } \\\n static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector min() Vc_NOEXCEPT \\\n { \\\n return _min; \\\n } \\\n static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector lowest() Vc_NOEXCEPT \\\n { \\\n return min(); \\\n } \\\n static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector epsilon() Vc_NOEXCEPT \\\n { \\\n return Vc::AVX2::Vector::Zero(); \\\n } \\\n static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector round_error() Vc_NOEXCEPT \\\n { \\\n return Vc::AVX2::Vector::Zero(); \\\n } \\\n static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector infinity() Vc_NOEXCEPT \\\n { \\\n return Vc::AVX2::Vector::Zero(); \\\n } \\\n static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector quiet_NaN() Vc_NOEXCEPT \\\n { \\\n return Vc::AVX2::Vector::Zero(); \\\n } \\\n static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector signaling_NaN() Vc_NOEXCEPT \\\n { \\\n return Vc::AVX2::Vector::Zero(); \\\n } \\\n static Vc_INTRINSIC Vc_CONST Vc::AVX2::Vector denorm_min() Vc_NOEXCEPT \\\n { \\\n return Vc::AVX2::Vector::Zero(); \\\n } \\\n }\n\n#ifdef Vc_IMPL_AVX2\nVc_NUM_LIM(unsigned short, Vc::Detail::allone<__m256i>(), Vc::Detail::zero<__m256i>());\nVc_NUM_LIM( short, _mm256_srli_epi16(Vc::Detail::allone<__m256i>(), 1), Vc::AVX::setmin_epi16());\nVc_NUM_LIM( unsigned int, Vc::Detail::allone<__m256i>(), Vc::Detail::zero<__m256i>());\nVc_NUM_LIM( int, _mm256_srli_epi32(Vc::Detail::allone<__m256i>(), 1), Vc::AVX::setmin_epi32());\n#endif\n#undef Vc_NUM_LIM\n\n} // namespace std\n\n#endif // VC_AVX_LIMITS_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/macros.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#include \"../common/macros.h\"\n\n#ifndef VC_AVX_MACROS_H_\n#define VC_AVX_MACROS_H_\n\n#endif // VC_AVX_MACROS_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/mask.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_MASK_H_\n#define VC_AVX_MASK_H_\n\n#include \n\n#include \"intrinsics.h\"\n#include \"../common/storage.h\"\n#include \"../common/bitscanintrinsics.h\"\n#include \"../common/maskbool.h\"\n#include \"detail.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\ntemplate class Mask\n{\npublic:\n using abi = VectorAbi::Avx;\n\n /**\n * The \\c EntryType of masks is always bool, independent of \\c T.\n */\n typedef bool EntryType;\n using value_type = EntryType;\n\n using MaskBool = Common::MaskBool;\n /**\n * The \\c VectorEntryType, in contrast to \\c EntryType, reveals information about the SIMD\n * implementation. This type is useful for the \\c sizeof operator in generic functions.\n */\n using VectorEntryType = MaskBool;\n\n /**\n * The associated Vector type.\n */\n using Vector = AVX2::Vector;\n\n ///\\internal\n using VectorTypeF = AVX::FloatVectorType::Type>;\n ///\\internal\n using VectorTypeD = AVX::DoubleVectorType;\n ///\\internal\n using VectorTypeI = AVX::IntegerVectorType;\n\nprivate:\n typedef const VectorTypeF VArg;\n typedef const VectorTypeD VdArg;\n typedef const VectorTypeI ViArg;\n\npublic:\n static constexpr size_t Size = sizeof(VectorTypeF) / sizeof(T);\n static constexpr size_t MemoryAlignment = Size;\n static constexpr std::size_t size() { return Size; }\n Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(VectorType));\n\nprivate:\n typedef Common::Storage Storage;\n\npublic:\n /**\n * The \\c VectorType reveals the implementation-specific internal type used for the\n * SIMD type.\n */\n using VectorType = typename Storage::VectorType;\n\n using EntryReference = Vc::Detail::ElementReference;\n using reference = EntryReference;\n\n // abstracts the way Masks are passed to functions, it can easily be changed to const ref here\n#if defined Vc_MSVC && defined _WIN32\n typedef const Mask &AsArg;\n#else\n typedef const Mask AsArg;\n#endif\n\n Vc_INTRINSIC Mask() {}\n Vc_INTRINSIC Mask(VArg x) : d(AVX::avx_cast(x)) {}\n Vc_INTRINSIC Mask(VdArg x) : d(AVX::avx_cast(x)) {}\n Vc_INTRINSIC Mask(ViArg x) : d(AVX::avx_cast(x)) {}\n Vc_INTRINSIC explicit Mask(VectorSpecialInitializerZero) : d(Detail::zero()) {}\n Vc_INTRINSIC explicit Mask(VectorSpecialInitializerOne) : d(Detail::allone()) {}\n Vc_INTRINSIC explicit Mask(bool b)\n : d(b ? Detail::allone() : Detail::zero())\n {\n }\n Vc_INTRINSIC static Mask Zero() { return Mask{Vc::Zero}; }\n Vc_INTRINSIC static Mask One() { return Mask{Vc::One}; }\n\n // implicit cast\n template \n Vc_INTRINSIC Mask(\n U &&rhs, Common::enable_if_mask_converts_implicitly = nullarg)\n : d(AVX::avx_cast(\n Detail::mask_cast::Size, Size, VectorTypeF>(\n rhs.dataI())))\n {\n }\n\n#if Vc_IS_VERSION_1\n // explicit cast, implemented via simd_cast (in avx/simd_cast_caller.h)\n template \n Vc_DEPRECATED(\"use simd_cast instead of explicit type casting to convert between \"\n \"mask types\") Vc_INTRINSIC\n explicit Mask(U &&rhs,\n Common::enable_if_mask_converts_explicitly = nullarg);\n#endif\n\n template Vc_INTRINSIC explicit Mask(const bool *mem, Flags f = Flags()) { load(mem, f); }\n\n template Vc_INTRINSIC void load(const bool *mem, Flags = Flags());\n\n template Vc_INTRINSIC void store(bool *mem, Flags = Flags()) const;\n\n Vc_INTRINSIC Mask &operator=(const Mask &) = default;\n Vc_INTRINSIC_L Mask &operator=(const std::array &values) Vc_INTRINSIC_R;\n Vc_INTRINSIC_L operator std::array() const Vc_INTRINSIC_R;\n\n // specializations in mask.tcc\n Vc_INTRINSIC Vc_PURE bool operator==(const Mask &rhs) const\n { return Detail::movemask(d.v()) == Detail::movemask(rhs.d.v()); }\n\n Vc_INTRINSIC Vc_PURE bool operator!=(const Mask &rhs) const\n { return !operator==(rhs); }\n\n Vc_INTRINSIC Mask operator!() const\n {\n#ifdef Vc_GCC\n return ~dataI();\n#else\n return Detail::andnot_(dataF(), Detail::allone());\n#endif\n }\n\n Vc_INTRINSIC Mask &operator&=(const Mask &rhs) { d.v() = AVX::avx_cast(Detail::and_(data(), rhs.data())); return *this; }\n Vc_INTRINSIC Mask &operator|=(const Mask &rhs) { d.v() = AVX::avx_cast(Detail::or_ (data(), rhs.data())); return *this; }\n Vc_INTRINSIC Mask &operator^=(const Mask &rhs) { d.v() = AVX::avx_cast(Detail::xor_(data(), rhs.data())); return *this; }\n\n Vc_INTRINSIC Vc_PURE Mask operator&(const Mask &rhs) const { return Detail::and_(data(), rhs.data()); }\n Vc_INTRINSIC Vc_PURE Mask operator|(const Mask &rhs) const { return Detail::or_(data(), rhs.data()); }\n Vc_INTRINSIC Vc_PURE Mask operator^(const Mask &rhs) const { return Detail::xor_(data(), rhs.data()); }\n\n Vc_INTRINSIC Vc_PURE Mask operator&&(const Mask &rhs) const { return Detail::and_(data(), rhs.data()); }\n Vc_INTRINSIC Vc_PURE Mask operator||(const Mask &rhs) const { return Detail::or_(data(), rhs.data()); }\n\n // no need for expression template optimizations because cmp(n)eq for floats are not bitwise\n // compares\n Vc_INTRINSIC_L bool isNotEmpty() const Vc_INTRINSIC_R;\n Vc_INTRINSIC_L bool isEmpty() const Vc_INTRINSIC_R;\n Vc_INTRINSIC_L bool isFull() const Vc_INTRINSIC_R;\n Vc_INTRINSIC_L bool isMix() const Vc_INTRINSIC_R;\n\n Vc_INTRINSIC Vc_PURE int shiftMask() const { return Detail::movemask(dataI()); }\n Vc_INTRINSIC Vc_PURE int toInt() const { return Detail::mask_to_int(dataI()); }\n\n Vc_INTRINSIC VectorType data () const { return d.v(); }\n Vc_INTRINSIC VectorTypeF dataF() const { return AVX::avx_cast(d.v()); }\n Vc_INTRINSIC VectorTypeI dataI() const { return AVX::avx_cast(d.v()); }\n Vc_INTRINSIC VectorTypeD dataD() const { return AVX::avx_cast(d.v()); }\n\nprivate:\n friend reference;\n static Vc_INTRINSIC Vc_PURE value_type get(const Mask &m, int i) noexcept\n {\n return m.toInt() & (1 << i);\n }\n template \n static Vc_INTRINSIC void set(Mask &m, int i,\n U &&v) noexcept(noexcept(MaskBool(std::declval())))\n {\n m.d.set(i, MaskBool(std::forward(v)));\n }\n\npublic:\n /**\n * \\note the returned object models the concept of a reference and\n * as such it can exist longer than the data it is referencing.\n * \\note to avoid lifetime issues, we strongly advice not to store\n * any reference objects.\n */\n Vc_ALWAYS_INLINE reference operator[](size_t index) noexcept\n {\n return {*this, int(index)};\n }\n Vc_ALWAYS_INLINE Vc_PURE value_type operator[](size_t index) const noexcept\n {\n return get(*this, index);\n }\n\n Vc_INTRINSIC Vc_PURE int count() const { return Detail::popcnt16(toInt()); }\n Vc_INTRINSIC Vc_PURE int firstOne() const { return _bit_scan_forward(toInt()); }\n\n template static Vc_INTRINSIC_L Mask generate(G &&gen) Vc_INTRINSIC_R;\n Vc_INTRINSIC_L Vc_PURE_L Mask shifted(int amount) const Vc_INTRINSIC_R Vc_PURE_R;\n\n private:\n#ifdef Vc_COMPILE_BENCHMARKS\n public:\n#endif\n Storage d;\n};\ntemplate constexpr size_t Mask::Size;\ntemplate constexpr size_t Mask::MemoryAlignment;\n\n} // namespace Vc\n\n#include \"mask.tcc\"\n\n#endif // VC_AVX_MASK_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/mask.tcc", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2011-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n// store {{{1\ntemplate \ntemplate \nVc_INTRINSIC void Mask::store(bool *mem, Flags f) const\n{\n Detail::mask_store(dataI(), mem, f);\n}\n\n// load {{{1\ntemplate \ntemplate \nVc_INTRINSIC void Mask::load(const bool *mem, Flags f)\n{\n d.v() = AVX::avx_cast(Detail::mask_load(mem, f));\n}\n\n// operator[] {{{1\n#ifdef Vc_IMPL_AVX2\ntemplate <>\nVc_INTRINSIC Vc_PURE bool AVX2::Mask::get(const AVX2::Mask &m,\n int index) noexcept\n{\n return m.shiftMask() & (1 << 2 * index);\n}\ntemplate <>\nVc_INTRINSIC Vc_PURE bool AVX2::Mask::get(const AVX2::Mask &m,\n int index) noexcept\n{\n return m.shiftMask() & (1 << 2 * index);\n}\n#endif\n// operator== {{{1\ntemplate <> Vc_INTRINSIC Vc_PURE bool AVX2::double_m::operator==(const AVX2::double_m &rhs) const\n{ return Detail::movemask(dataD()) == Detail::movemask(rhs.dataD()); }\n#ifdef Vc_IMPL_AVX2\ntemplate <> Vc_INTRINSIC Vc_PURE bool AVX2::short_m::operator==(const AVX2::short_m &rhs) const\n{ return Detail::movemask(dataI()) == Detail::movemask(rhs.dataI()); }\ntemplate <> Vc_INTRINSIC Vc_PURE bool AVX2::ushort_m::operator==(const AVX2::ushort_m &rhs) const\n{ return Detail::movemask(dataI()) == Detail::movemask(rhs.dataI()); }\n#endif\n\n// isFull, isNotEmpty, isEmpty, isMix specializations{{{1\ntemplate Vc_INTRINSIC bool Mask::isFull() const {\n if (sizeof(T) == 8) {\n return 0 != Detail::testc(dataD(), Detail::allone());\n } else if (sizeof(T) == 4) {\n return 0 != Detail::testc(dataF(), Detail::allone());\n } else {\n return 0 != Detail::testc(dataI(), Detail::allone());\n }\n}\n\ntemplate Vc_INTRINSIC bool Mask::isNotEmpty() const {\n if (sizeof(T) == 8) {\n return 0 == Detail::testz(dataD(), dataD());\n } else if (sizeof(T) == 4) {\n return 0 == Detail::testz(dataF(), dataF());\n } else {\n return 0 == Detail::testz(dataI(), dataI());\n }\n}\n\ntemplate Vc_INTRINSIC bool Mask::isEmpty() const {\n if (sizeof(T) == 8) {\n return 0 != Detail::testz(dataD(), dataD());\n } else if (sizeof(T) == 4) {\n return 0 != Detail::testz(dataF(), dataF());\n } else {\n return 0 != Detail::testz(dataI(), dataI());\n }\n}\n\ntemplate Vc_INTRINSIC bool Mask::isMix() const {\n if (sizeof(T) == 8) {\n return 0 != Detail::testnzc(dataD(), Detail::allone());\n } else if (sizeof(T) == 4) {\n return 0 != Detail::testnzc(dataF(), Detail::allone());\n } else {\n return 0 != Detail::testnzc(dataI(), Detail::allone());\n }\n}\n\n// generate {{{1\ntemplate \nVc_INTRINSIC M generate_impl(G &&gen, std::integral_constant)\n{\n return _mm256_setr_epi64x(\n gen(0) ? 0xffffffffffffffffull : 0, gen(1) ? 0xffffffffffffffffull : 0,\n gen(2) ? 0xffffffffffffffffull : 0, gen(3) ? 0xffffffffffffffffull : 0);\n}\ntemplate \nVc_INTRINSIC M generate_impl(G &&gen, std::integral_constant)\n{\n return _mm256_setr_epi32(gen(0) ? 0xfffffffful : 0, gen(1) ? 0xfffffffful : 0,\n gen(2) ? 0xfffffffful : 0, gen(3) ? 0xfffffffful : 0,\n gen(4) ? 0xfffffffful : 0, gen(5) ? 0xfffffffful : 0,\n gen(6) ? 0xfffffffful : 0, gen(7) ? 0xfffffffful : 0);\n}\ntemplate \nVc_INTRINSIC M generate_impl(G &&gen, std::integral_constant)\n{\n return _mm256_setr_epi16(gen(0) ? 0xfffful : 0, gen(1) ? 0xfffful : 0,\n gen(2) ? 0xfffful : 0, gen(3) ? 0xfffful : 0,\n gen(4) ? 0xfffful : 0, gen(5) ? 0xfffful : 0,\n gen(6) ? 0xfffful : 0, gen(7) ? 0xfffful : 0,\n gen(8) ? 0xfffful : 0, gen(9) ? 0xfffful : 0,\n gen(10) ? 0xfffful : 0, gen(11) ? 0xfffful : 0,\n gen(12) ? 0xfffful : 0, gen(13) ? 0xfffful : 0,\n gen(14) ? 0xfffful : 0, gen(15) ? 0xfffful : 0);\n}\ntemplate \ntemplate \nVc_INTRINSIC AVX2::Mask Mask::generate(G &&gen)\n{\n return generate_impl>(std::forward(gen),\n std::integral_constant());\n}\n// shifted {{{1\ntemplate Vc_INTRINSIC Vc_PURE AVX2::Mask Mask::shifted(int amount) const\n{\n switch (amount * int(sizeof(VectorEntryType))) {\n case 0: return *this;\n case 1: return Detail::shifted< 1>(dataI());\n case 2: return Detail::shifted< 2>(dataI());\n case 3: return Detail::shifted< 3>(dataI());\n case 4: return Detail::shifted< 4>(dataI());\n case 5: return Detail::shifted< 5>(dataI());\n case 6: return Detail::shifted< 6>(dataI());\n case 7: return Detail::shifted< 7>(dataI());\n case 8: return Detail::shifted< 8>(dataI());\n case 9: return Detail::shifted< 9>(dataI());\n case 10: return Detail::shifted< 10>(dataI());\n case 11: return Detail::shifted< 11>(dataI());\n case 12: return Detail::shifted< 12>(dataI());\n case 13: return Detail::shifted< 13>(dataI());\n case 14: return Detail::shifted< 14>(dataI());\n case 15: return Detail::shifted< 15>(dataI());\n case 16: return Detail::shifted< 16>(dataI());\n case 17: return Detail::shifted< 17>(dataI());\n case 18: return Detail::shifted< 18>(dataI());\n case 19: return Detail::shifted< 19>(dataI());\n case 20: return Detail::shifted< 20>(dataI());\n case 21: return Detail::shifted< 21>(dataI());\n case 22: return Detail::shifted< 22>(dataI());\n case 23: return Detail::shifted< 23>(dataI());\n case 24: return Detail::shifted< 24>(dataI());\n case 25: return Detail::shifted< 25>(dataI());\n case 26: return Detail::shifted< 26>(dataI());\n case 27: return Detail::shifted< 27>(dataI());\n case 28: return Detail::shifted< 28>(dataI());\n case 29: return Detail::shifted< 29>(dataI());\n case 30: return Detail::shifted< 30>(dataI());\n case 31: return Detail::shifted< 31>(dataI());\n case -1: return Detail::shifted< -1>(dataI());\n case -2: return Detail::shifted< -2>(dataI());\n case -3: return Detail::shifted< -3>(dataI());\n case -4: return Detail::shifted< -4>(dataI());\n case -5: return Detail::shifted< -5>(dataI());\n case -6: return Detail::shifted< -6>(dataI());\n case -7: return Detail::shifted< -7>(dataI());\n case -8: return Detail::shifted< -8>(dataI());\n case -9: return Detail::shifted< -9>(dataI());\n case -10: return Detail::shifted<-10>(dataI());\n case -11: return Detail::shifted<-11>(dataI());\n case -12: return Detail::shifted<-12>(dataI());\n case -13: return Detail::shifted<-13>(dataI());\n case -14: return Detail::shifted<-14>(dataI());\n case -15: return Detail::shifted<-15>(dataI());\n case -16: return Detail::shifted<-16>(dataI());\n case -17: return Detail::shifted<-17>(dataI());\n case -18: return Detail::shifted<-18>(dataI());\n case -19: return Detail::shifted<-19>(dataI());\n case -20: return Detail::shifted<-20>(dataI());\n case -21: return Detail::shifted<-21>(dataI());\n case -22: return Detail::shifted<-22>(dataI());\n case -23: return Detail::shifted<-23>(dataI());\n case -24: return Detail::shifted<-24>(dataI());\n case -25: return Detail::shifted<-25>(dataI());\n case -26: return Detail::shifted<-26>(dataI());\n case -27: return Detail::shifted<-27>(dataI());\n case -28: return Detail::shifted<-28>(dataI());\n case -29: return Detail::shifted<-29>(dataI());\n case -30: return Detail::shifted<-30>(dataI());\n case -31: return Detail::shifted<-31>(dataI());\n }\n return Zero();\n}\n// }}}1\n\n/*\ntemplate<> Vc_INTRINSIC AVX2::Mask< 4, 32> &AVX2::Mask< 4, 32>::operator=(const std::array &values) {\n static_assert(sizeof(bool) == 1, \"Vc expects bool to have a sizeof 1 Byte\");\n unsigned int x = *reinterpret_cast(values.data());\n x *= 0xffu;\n __m128i y = _mm_cvtsi32_si128(x); // 4 Bytes\n y = _mm_unpacklo_epi8(y, y); // 8 Bytes\n y = _mm_unpacklo_epi16(y, y); // 16 Bytes\n d.v() = AVX::avx_cast<__m256>(AVX::concat(_mm_unpacklo_epi32(y, y), _mm_unpackhi_epi32(y, y)));\n return *this;\n}\ntemplate<> Vc_INTRINSIC AVX2::Mask< 8, 32> &AVX2::Mask< 8, 32>::operator=(const std::array &values) {\n static_assert(sizeof(bool) == 1, \"Vc expects bool to have a sizeof 1 Byte\");\n unsigned long long x = *reinterpret_cast(values.data());\n x *= 0xffull;\n __m128i y = _mm_cvtsi64_si128(x); // 8 Bytes\n y = _mm_unpacklo_epi8(y, y); // 16 Bytes\n d.v() = AVX::avx_cast<__m256>(AVX::concat(_mm_unpacklo_epi16(y, y), _mm_unpackhi_epi16(y, y)));\n return *this;\n}\ntemplate<> Vc_INTRINSIC AVX2::Mask< 8, 16> &AVX2::Mask< 8, 16>::operator=(const std::array &values) {\n static_assert(sizeof(bool) == 1, \"Vc expects bool to have a sizeof 1 Byte\");\n unsigned long long x = *reinterpret_cast(values.data());\n x *= 0xffull;\n __m128i y = _mm_cvtsi64_si128(x); // 8 Bytes\n d.v() = AVX::avx_cast<__m128>(_mm_unpacklo_epi8(y, y));\n return *this;\n}\ntemplate<> Vc_INTRINSIC AVX2::Mask<16, 16> &AVX2::Mask<16, 16>::operator=(const std::array &values) {\n static_assert(sizeof(bool) == 1, \"Vc expects bool to have a sizeof 1 Byte\");\n __m128i x = _mm_loadu_si128(reinterpret_cast(values.data()));\n d.v() = _mm_andnot_ps(AVX::_mm_setallone_ps(), AVX::avx_cast<__m128>(_mm_sub_epi8(x, _mm_set1_epi8(1))));\n return *this;\n}\n\ntemplate<> Vc_INTRINSIC AVX2::Mask< 4, 32>::operator std::array() const {\n static_assert(sizeof(bool) == 1, \"Vc expects bool to have a sizeof 1 Byte\");\n __m128i x = _mm_packs_epi32(AVX::lo128(dataI()), AVX::hi128(dataI())); // 64bit -> 32bit\n x = _mm_packs_epi32(x, x); // 32bit -> 16bit\n x = _mm_srli_epi16(x, 15);\n x = _mm_packs_epi16(x, x); // 16bit -> 8bit\n std::array r;\n asm volatile(\"vmovd %1,%0\" : \"=m\"(*r.data()) : \"x\"(x));\n return r;\n}\ntemplate<> Vc_INTRINSIC AVX2::Mask< 8, 32>::operator std::array() const {\n static_assert(sizeof(bool) == 1, \"Vc expects bool to have a sizeof 1 Byte\");\n __m128i x = _mm_packs_epi32(AVX::lo128(dataI()), AVX::hi128(dataI())); // 32bit -> 16bit\n x = _mm_srli_epi16(x, 15);\n x = _mm_packs_epi16(x, x); // 16bit -> 8bit\n std::array r;\n asm volatile(\"vmovq %1,%0\" : \"=m\"(*r.data()) : \"x\"(x));\n return r;\n}\ntemplate<> Vc_INTRINSIC AVX2::Mask< 8, 16>::operator std::array() const {\n static_assert(sizeof(bool) == 1, \"Vc expects bool to have a sizeof 1 Byte\");\n __m128i x = _mm_srli_epi16(dataI(), 15);\n x = _mm_packs_epi16(x, x); // 16bit -> 8bit\n std::array r;\n asm volatile(\"vmovq %1,%0\" : \"=m\"(*r.data()) : \"x\"(x));\n return r;\n}\ntemplate<> Vc_INTRINSIC AVX2::Mask<16, 16>::operator std::array() const {\n static_assert(sizeof(bool) == 1, \"Vc expects bool to have a sizeof 1 Byte\");\n __m128 x = _mm_and_ps(d.v(), AVX::avx_cast<__m128>(_mm_set1_epi32(0x01010101)));\n std::array r;\n asm volatile(\"vmovups %1,%0\" : \"=m\"(*r.data()) : \"x\"(x));\n return r;\n}\n*/\n\n}\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/avx/math.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_MATH_H_\n#define VC_AVX_MATH_H_\n\n#include \"const.h\"\n#include \"limits.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n// min & max {{{1\n#ifdef Vc_IMPL_AVX2\nVc_ALWAYS_INLINE AVX2::int_v min(const AVX2::int_v &x, const AVX2::int_v &y) { return _mm256_min_epi32(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::uint_v min(const AVX2::uint_v &x, const AVX2::uint_v &y) { return _mm256_min_epu32(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::short_v min(const AVX2::short_v &x, const AVX2::short_v &y) { return _mm256_min_epi16(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::ushort_v min(const AVX2::ushort_v &x, const AVX2::ushort_v &y) { return _mm256_min_epu16(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::int_v max(const AVX2::int_v &x, const AVX2::int_v &y) { return _mm256_max_epi32(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::uint_v max(const AVX2::uint_v &x, const AVX2::uint_v &y) { return _mm256_max_epu32(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::short_v max(const AVX2::short_v &x, const AVX2::short_v &y) { return _mm256_max_epi16(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::ushort_v max(const AVX2::ushort_v &x, const AVX2::ushort_v &y) { return _mm256_max_epu16(x.data(), y.data()); }\n#endif\nVc_ALWAYS_INLINE AVX2::float_v min(const AVX2::float_v &x, const AVX2::float_v &y) { return _mm256_min_ps(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::double_v min(const AVX2::double_v &x, const AVX2::double_v &y) { return _mm256_min_pd(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::float_v max(const AVX2::float_v &x, const AVX2::float_v &y) { return _mm256_max_ps(x.data(), y.data()); }\nVc_ALWAYS_INLINE AVX2::double_v max(const AVX2::double_v &x, const AVX2::double_v &y) { return _mm256_max_pd(x.data(), y.data()); }\n\n// sqrt {{{1\ntemplate \nVc_ALWAYS_INLINE Vc_PURE AVX2::Vector sqrt(const AVX2::Vector &x)\n{\n return AVX::VectorHelper::sqrt(x.data());\n}\n\n// rsqrt {{{1\ntemplate \nVc_ALWAYS_INLINE Vc_PURE AVX2::Vector rsqrt(const AVX2::Vector &x)\n{\n return AVX::VectorHelper::rsqrt(x.data());\n}\n\n// reciprocal {{{1\ntemplate \nVc_ALWAYS_INLINE Vc_PURE AVX2::Vector reciprocal(const AVX2::Vector &x)\n{\n return AVX::VectorHelper::reciprocal(x.data());\n}\n\n// round {{{1\ntemplate \nVc_ALWAYS_INLINE Vc_PURE AVX2::Vector round(const AVX2::Vector &x)\n{\n return AVX::VectorHelper::round(x.data());\n}\n\n// abs {{{1\nVc_INTRINSIC Vc_CONST AVX2::double_v abs(AVX2::double_v x)\n{\n return Detail::and_(x.data(), AVX::setabsmask_pd());\n}\nVc_INTRINSIC Vc_CONST AVX2::float_v abs(AVX2::float_v x)\n{\n return Detail::and_(x.data(), AVX::setabsmask_ps());\n}\n#ifdef Vc_IMPL_AVX2\nVc_INTRINSIC Vc_CONST AVX2::int_v abs(AVX2::int_v x)\n{\n return _mm256_abs_epi32(x.data());\n}\nVc_INTRINSIC Vc_CONST AVX2::short_v abs(AVX2::short_v x)\n{\n return _mm256_abs_epi16(x.data());\n}\n#endif\n\n// isfinite {{{1\nVc_ALWAYS_INLINE Vc_PURE AVX2::double_m isfinite(const AVX2::double_v &x)\n{\n return AVX::cmpord_pd(x.data(), _mm256_mul_pd(Detail::zero<__m256d>(), x.data()));\n}\n\nVc_ALWAYS_INLINE Vc_PURE AVX2::float_m isfinite(const AVX2::float_v &x)\n{\n return AVX::cmpord_ps(x.data(), _mm256_mul_ps(Detail::zero<__m256>(), x.data()));\n}\n\n// isinf {{{1\nVc_ALWAYS_INLINE Vc_PURE AVX2::double_m isinf(const AVX2::double_v &x)\n{\n return _mm256_castsi256_pd(AVX::cmpeq_epi64(\n _mm256_castpd_si256(abs(x).data()),\n _mm256_castpd_si256(Detail::avx_broadcast(AVX::c_log::d(1)))));\n}\n\nVc_ALWAYS_INLINE Vc_PURE AVX2::float_m isinf(const AVX2::float_v &x)\n{\n return _mm256_castsi256_ps(\n AVX::cmpeq_epi32(_mm256_castps_si256(abs(x).data()),\n _mm256_castps_si256(Detail::avx_broadcast(AVX::c_log::d(1)))));\n}\n\n// isnan {{{1\nVc_ALWAYS_INLINE Vc_PURE AVX2::double_m isnan(const AVX2::double_v &x)\n{\n return AVX::cmpunord_pd(x.data(), x.data());\n}\n\nVc_ALWAYS_INLINE Vc_PURE AVX2::float_m isnan(const AVX2::float_v &x)\n{\n return AVX::cmpunord_ps(x.data(), x.data());\n}\n\n// copysign {{{1\nVc_INTRINSIC Vc_CONST AVX2::float_v copysign(AVX2::float_v mag, AVX2::float_v sign)\n{\n return _mm256_or_ps(_mm256_and_ps(sign.data(), AVX::setsignmask_ps()),\n _mm256_and_ps(mag.data(), AVX::setabsmask_ps()));\n}\nVc_INTRINSIC Vc_CONST AVX2::double_v copysign(AVX2::double_v::AsArg mag,\n AVX2::double_v::AsArg sign)\n{\n return _mm256_or_pd(_mm256_and_pd(sign.data(), AVX::setsignmask_pd()),\n _mm256_and_pd(mag.data(), AVX::setabsmask_pd()));\n}\n\n//}}}1\n// frexp {{{1\n/**\n * splits \\p v into exponent and mantissa, the sign is kept with the mantissa\n *\n * The return value will be in the range [0.5, 1.0[\n * The \\p e value will be an integer defining the power-of-two exponent\n */\ninline AVX2::double_v frexp(AVX2::double_v::AsArg v, SimdArray *e)\n{\n const __m256d exponentBits = AVX::Const::exponentMask().dataD();\n const __m256d exponentPart = _mm256_and_pd(v.data(), exponentBits);\n auto lo = AVX::avx_cast<__m128i>(AVX::lo128(exponentPart));\n auto hi = AVX::avx_cast<__m128i>(AVX::hi128(exponentPart));\n lo = _mm_sub_epi32(_mm_srli_epi64(lo, 52), _mm_set1_epi64x(0x3fe));\n hi = _mm_sub_epi32(_mm_srli_epi64(hi, 52), _mm_set1_epi64x(0x3fe));\n SSE::int_v exponent = Mem::shuffle(lo, hi);\n const __m256d exponentMaximized = _mm256_or_pd(v.data(), exponentBits);\n AVX2::double_v ret =\n _mm256_and_pd(exponentMaximized,\n _mm256_broadcast_sd(reinterpret_cast(&AVX::c_general::frexpMask)));\n const double_m zeroMask = v == AVX2::double_v::Zero();\n ret(isnan(v) || !isfinite(v) || zeroMask) = v;\n exponent.setZero(simd_cast(zeroMask));\n internal_data(*e) = exponent;\n return ret;\n}\n\n#ifdef Vc_IMPL_AVX2\ninline SimdArray frexp(const SimdArray &v, SimdArray *e)\n{\n const __m256d exponentBits = AVX::Const::exponentMask().dataD();\n const __m256d w[2] = {internal_data(internal_data0(v)).data(),\n internal_data(internal_data1(v)).data()};\n const __m256i exponentPart[2] = {\n _mm256_castpd_si256(_mm256_and_pd(w[0], exponentBits)),\n _mm256_castpd_si256(_mm256_and_pd(w[1], exponentBits))};\n const __m256i lo = _mm256_sub_epi32(_mm256_srli_epi64(exponentPart[0], 52),\n _mm256_set1_epi32(0x3fe)); // 0.1. 2.3.\n const __m256i hi = _mm256_sub_epi32(_mm256_srli_epi64(exponentPart[1], 52),\n _mm256_set1_epi32(0x3fe)); // 4.5. 6.7.\n const __m256i a = _mm256_unpacklo_epi32(lo, hi); // 04.. 26..\n const __m256i b = _mm256_unpackhi_epi32(lo, hi); // 15.. 37..\n const __m256i tmp = _mm256_unpacklo_epi32(a, b); // 0145 2367\n const __m256i exponent =\n AVX::concat(_mm_unpacklo_epi64(AVX::lo128(tmp), AVX::hi128(tmp)),\n _mm_unpackhi_epi64(AVX::lo128(tmp), AVX::hi128(tmp))); // 0123 4567\n const __m256d exponentMaximized[2] = {_mm256_or_pd(w[0], exponentBits),\n _mm256_or_pd(w[1], exponentBits)};\n const auto frexpMask =\n _mm256_broadcast_sd(reinterpret_cast(&AVX::c_general::frexpMask));\n fixed_size_simd ret = {\n fixed_size_simd(\n AVX::double_v(_mm256_and_pd(exponentMaximized[0], frexpMask))),\n fixed_size_simd(\n AVX::double_v(_mm256_and_pd(exponentMaximized[1], frexpMask)))};\n const auto zeroMask = v == v.Zero();\n ret(isnan(v) || !isfinite(v) || zeroMask) = v;\n internal_data(*e) =\n Detail::andnot_(simd_cast(zeroMask).dataI(), exponent);\n return ret;\n}\n#endif // Vc_IMPL_AVX2\n\nnamespace Detail\n{\nVc_INTRINSIC AVX2::float_v::IndexType extractExponent(__m256 e)\n{\n SimdArray exponentPart;\n const auto ee = AVX::avx_cast<__m256i>(e);\n#ifdef Vc_IMPL_AVX2\n exponentPart = AVX2::uint_v(ee);\n#else\n internal_data(internal_data0(exponentPart)) = AVX::lo128(ee);\n internal_data(internal_data1(exponentPart)) = AVX::hi128(ee);\n#endif\n return (exponentPart >> 23) - 0x7e;\n}\n} // namespace Detail\ninline AVX2::float_v frexp(AVX2::float_v::AsArg v, SimdArray *e)\n{\n using namespace Detail;\n using namespace AVX2;\n const __m256 exponentBits = Const::exponentMask().data();\n *e = extractExponent(and_(v.data(), exponentBits));\n const __m256 exponentMaximized = or_(v.data(), exponentBits);\n AVX2::float_v ret = _mm256_and_ps(exponentMaximized, avx_cast<__m256>(set1_epi32(0xbf7fffffu)));\n ret(isnan(v) || !isfinite(v) || v == AVX2::float_v::Zero()) = v;\n e->setZero(simd_cast(v == AVX2::float_v::Zero()));\n return ret;\n}\n\n// ldexp {{{1\n/* -> x * 2^e\n * x == NaN -> NaN\n * x == (-)inf -> (-)inf\n */\ninline AVX2::double_v ldexp(AVX2::double_v::AsArg v, const SimdArray &_e)\n{\n SSE::int_v e = internal_data(_e);\n e.setZero(simd_cast(v == AVX2::double_v::Zero()));\n const __m256i exponentBits =\n AVX::concat(_mm_slli_epi64(_mm_unpacklo_epi32(e.data(), e.data()), 52),\n _mm_slli_epi64(_mm_unpackhi_epi32(e.data(), e.data()), 52));\n return AVX::avx_cast<__m256d>(\n AVX::add_epi64(AVX::avx_cast<__m256i>(v.data()), exponentBits));\n}\ninline AVX2::float_v ldexp(AVX2::float_v::AsArg v, SimdArray e)\n{\n e.setZero(simd_cast(v == AVX2::float_v::Zero()));\n e <<= 23;\n#ifdef Vc_IMPL_AVX2\n return {AVX::avx_cast<__m256>(\n AVX::concat(_mm_add_epi32(AVX::avx_cast<__m128i>(AVX::lo128(v.data())),\n AVX::lo128(internal_data(e).data())),\n _mm_add_epi32(AVX::avx_cast<__m128i>(AVX::hi128(v.data())),\n AVX::hi128(internal_data(e).data()))))};\n#else\n return {AVX::avx_cast<__m256>(\n AVX::concat(_mm_add_epi32(AVX::avx_cast<__m128i>(AVX::lo128(v.data())),\n internal_data(internal_data0(e)).data()),\n _mm_add_epi32(AVX::avx_cast<__m128i>(AVX::hi128(v.data())),\n internal_data(internal_data1(e)).data())))};\n#endif\n}\n\n// trunc {{{1\nVc_ALWAYS_INLINE AVX2::float_v trunc(AVX2::float_v::AsArg v)\n{\n return _mm256_round_ps(v.data(), 0x3);\n}\nVc_ALWAYS_INLINE AVX2::double_v trunc(AVX2::double_v::AsArg v)\n{\n return _mm256_round_pd(v.data(), 0x3);\n}\n\n// floor {{{1\nVc_ALWAYS_INLINE AVX2::float_v floor(AVX2::float_v::AsArg v)\n{\n return _mm256_floor_ps(v.data());\n}\nVc_ALWAYS_INLINE AVX2::double_v floor(AVX2::double_v::AsArg v)\n{\n return _mm256_floor_pd(v.data());\n}\n\n// ceil {{{1\nVc_ALWAYS_INLINE AVX2::float_v ceil(AVX2::float_v::AsArg v)\n{\n return _mm256_ceil_ps(v.data());\n}\nVc_ALWAYS_INLINE AVX2::double_v ceil(AVX2::double_v::AsArg v)\n{\n return _mm256_ceil_pd(v.data());\n}\n\n// fma {{{1\ntemplate \nVc_ALWAYS_INLINE Vector fma(Vector a,\n Vector b,\n Vector c)\n{\n return Detail::fma(a.data(), b.data(), c.data(), T());\n}\n\n// }}}1\n} // namespace Vc\n\n#endif // VC_AVX_MATH_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/avx/shuffle.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2011-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_SHUFFLE_H_\n#define VC_AVX_SHUFFLE_H_\n\n#include \"../sse/shuffle.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Detail\n{\ntemplate struct Permutation {};\ntemplate struct Mask {};\n\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST __m256i\nblend(__m256i a, __m256i b, Mask)\n{\n static_assert((Sel0 == 0 || Sel0 == 1) && (Sel1 == 0 || Sel1 == 1) &&\n (Sel2 == 0 || Sel2 == 1) && (Sel3 == 0 || Sel3 == 1) &&\n (Sel4 == 0 || Sel4 == 1) && (Sel5 == 0 || Sel5 == 1) &&\n (Sel6 == 0 || Sel6 == 1) && (Sel7 == 0 || Sel7 == 1) &&\n (Sel8 == 0 || Sel8 == 1) && (Sel9 == 0 || Sel9 == 1) &&\n (Sel10 == 0 || Sel10 == 1) && (Sel11 == 0 || Sel11 == 1) &&\n (Sel12 == 0 || Sel12 == 1) && (Sel13 == 0 || Sel13 == 1) &&\n (Sel14 == 0 || Sel14 == 1) && (Sel15 == 0 || Sel15 == 1),\n \"Selectors must be 0 or 1 to select the value from a or b\");\n constexpr uint8_t mask = static_cast(\n (Sel0 << 0 ) | (Sel1 << 1 ) | (Sel2 << 2 ) | (Sel3 << 3 ) |\n (Sel4 << 4 ) | (Sel5 << 5 ) | (Sel6 << 6 ) | (Sel7 << 7 ) |\n (Sel8 << 8 ) | (Sel9 << 9 ) | (Sel10 << 10) | (Sel11 << 11) |\n (Sel12 << 12) | (Sel13 << 13) | (Sel14 << 14) | (Sel15 << 15));\n return _mm256_blend_epi16(a, b, mask);\n}\n#endif // Vc_IMPL_AVX2\n} // namespace Detail\nnamespace Mem\n{\n#ifdef Vc_IMPL_AVX2\n template static Vc_ALWAYS_INLINE __m256i Vc_CONST permuteLo(__m256i x) {\n static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, \"Incorrect_Range\");\n static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, \"Incorrect_Range\");\n return _mm256_shufflelo_epi16(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);\n }\n\n template static Vc_ALWAYS_INLINE __m256i Vc_CONST permuteHi(__m256i x) {\n static_assert(Dst0 >= X4 && Dst1 >= X4 && Dst2 >= X4 && Dst3 >= X4, \"Incorrect_Range\");\n static_assert(Dst0 <= X7 && Dst1 <= X7 && Dst2 <= X7 && Dst3 <= X7, \"Incorrect_Range\");\n return _mm256_shufflehi_epi16(x, (Dst0 - X4) + (Dst1 - X4) * 4 + (Dst2 - X4) * 16 + (Dst3 - X4) * 64);\n }\n#endif // Vc_IMPL_AVX2\n\n template static Vc_ALWAYS_INLINE __m256 Vc_CONST permute128(__m256 x) {\n static_assert((L >= X0 && L <= X1) || L == Const0, \"Incorrect_Range\");\n static_assert((H >= X0 && H <= X1) || H == Const0, \"Incorrect_Range\");\n return _mm256_permute2f128_ps(\n x, x, (L == Const0 ? 0x8 : L) + (H == Const0 ? 0x80 : H * (1 << 4)));\n }\n template static Vc_ALWAYS_INLINE __m256d Vc_CONST permute128(__m256d x) {\n static_assert((L >= X0 && L <= X1) || L == Const0, \"Incorrect_Range\");\n static_assert((H >= X0 && H <= X1) || H == Const0, \"Incorrect_Range\");\n return _mm256_permute2f128_pd(\n x, x, (L == Const0 ? 0x8 : L) + (H == Const0 ? 0x80 : H * (1 << 4)));\n }\n template static Vc_ALWAYS_INLINE __m256i Vc_CONST permute128(__m256i x) {\n static_assert((L >= X0 && L <= X1) || L == Const0, \"Incorrect_Range\");\n static_assert((H >= X0 && H <= X1) || H == Const0, \"Incorrect_Range\");\n#ifdef Vc_IMPL_AVX2\n return _mm256_permute2x128_si256(\n x, x, (L == Const0 ? 0x8 : L) + (H == Const0 ? 0x80 : H * (1 << 4)));\n#else\n return _mm256_permute2f128_si256(\n x, x, (L == Const0 ? 0x8 : L) + (H == Const0 ? 0x80 : H * (1 << 4)));\n#endif\n }\n template static Vc_ALWAYS_INLINE __m256 Vc_CONST shuffle128(__m256 x, __m256 y) {\n static_assert(L >= X0 && H >= X0, \"Incorrect_Range\");\n static_assert(L <= Y1 && H <= Y1, \"Incorrect_Range\");\n return _mm256_permute2f128_ps(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));\n }\n template static Vc_ALWAYS_INLINE __m256i Vc_CONST shuffle128(__m256i x, __m256i y) {\n static_assert(L >= X0 && H >= X0, \"Incorrect_Range\");\n static_assert(L <= Y1 && H <= Y1, \"Incorrect_Range\");\n#ifdef Vc_IMPL_AVX2\n return _mm256_permute2x128_si256(\n x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));\n#else\n return _mm256_permute2f128_si256(\n x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));\n#endif\n }\n template static Vc_ALWAYS_INLINE __m256d Vc_CONST shuffle128(__m256d x, __m256d y) {\n static_assert(L >= X0 && H >= X0, \"Incorrect_Range\");\n static_assert(L <= Y1 && H <= Y1, \"Incorrect_Range\");\n return _mm256_permute2f128_pd(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));\n }\n template static Vc_ALWAYS_INLINE __m256d Vc_CONST permute(__m256d x) {\n static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X2 && Dst3 >= X2, \"Incorrect_Range\");\n static_assert(Dst0 <= X1 && Dst1 <= X1 && Dst2 <= X3 && Dst3 <= X3, \"Incorrect_Range\");\n return _mm256_permute_pd(x, Dst0 + Dst1 * 2 + (Dst2 - X2) * 4 + (Dst3 - X2) * 8);\n }\n template static Vc_ALWAYS_INLINE __m256 Vc_CONST permute(__m256 x) {\n static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, \"Incorrect_Range\");\n static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, \"Incorrect_Range\");\n return _mm256_permute_ps(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);\n }\n template static Vc_ALWAYS_INLINE __m256i Vc_CONST permute(__m256i x) {\n return _mm256_castps_si256(permute(_mm256_castsi256_ps(x)));\n }\n#ifdef Vc_IMPL_AVX2\n template static Vc_ALWAYS_INLINE __m256i Vc_CONST permute4x64(__m256i x) {\n static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, \"Incorrect_Range\");\n static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, \"Incorrect_Range\");\n return _mm256_permute4x64_epi64(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);\n }\n#endif // Vc_IMPL_AVX2\n template static Vc_ALWAYS_INLINE __m256d Vc_CONST shuffle(__m256d x, __m256d y) {\n static_assert(Dst0 >= X0 && Dst1 >= Y0 && Dst2 >= X2 && Dst3 >= Y2, \"Incorrect_Range\");\n static_assert(Dst0 <= X1 && Dst1 <= Y1 && Dst2 <= X3 && Dst3 <= Y3, \"Incorrect_Range\");\n return _mm256_shuffle_pd(x, y, Dst0 + (Dst1 - Y0) * 2 + (Dst2 - X2) * 4 + (Dst3 - Y2) * 8);\n }\n template static Vc_ALWAYS_INLINE __m256 Vc_CONST shuffle(__m256 x, __m256 y) {\n static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, \"Incorrect_Range\");\n static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, \"Incorrect_Range\");\n return _mm256_shuffle_ps(x, y, Dst0 + Dst1 * 4 + (Dst2 - Y0) * 16 + (Dst3 - Y0) * 64);\n }\n template\n static Vc_ALWAYS_INLINE __m256 Vc_CONST blend(__m256 x, __m256 y) {\n static_assert(Dst0 == X0 || Dst0 == Y0, \"Incorrect_Range\");\n static_assert(Dst1 == X1 || Dst1 == Y1, \"Incorrect_Range\");\n static_assert(Dst2 == X2 || Dst2 == Y2, \"Incorrect_Range\");\n static_assert(Dst3 == X3 || Dst3 == Y3, \"Incorrect_Range\");\n static_assert(Dst4 == X4 || Dst4 == Y4, \"Incorrect_Range\");\n static_assert(Dst5 == X5 || Dst5 == Y5, \"Incorrect_Range\");\n static_assert(Dst6 == X6 || Dst6 == Y6, \"Incorrect_Range\");\n static_assert(Dst7 == X7 || Dst7 == Y7, \"Incorrect_Range\");\n return _mm256_blend_ps(x, y,\n (Dst0 / Y0) * 1 + (Dst1 / Y1) * 2 +\n (Dst2 / Y2) * 4 + (Dst3 / Y3) * 8 +\n (Dst4 / Y4) * 16 + (Dst5 / Y5) * 32 +\n (Dst6 / Y6) * 64 + (Dst7 / Y7) *128\n );\n }\n template\n static Vc_ALWAYS_INLINE __m256i Vc_CONST blend(__m256i x, __m256i y) {\n return _mm256_castps_si256(blend(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y)));\n }\n template struct ScaleForBlend { enum { Value = Dst >= X4 ? Dst - X4 + Y0 : Dst }; };\n template\n static Vc_ALWAYS_INLINE __m256 Vc_CONST permute(__m256 x) {\n static_assert(Dst0 >= X0 && Dst0 <= X7, \"Incorrect_Range\");\n static_assert(Dst1 >= X0 && Dst1 <= X7, \"Incorrect_Range\");\n static_assert(Dst2 >= X0 && Dst2 <= X7, \"Incorrect_Range\");\n static_assert(Dst3 >= X0 && Dst3 <= X7, \"Incorrect_Range\");\n static_assert(Dst4 >= X0 && Dst4 <= X7, \"Incorrect_Range\");\n static_assert(Dst5 >= X0 && Dst5 <= X7, \"Incorrect_Range\");\n static_assert(Dst6 >= X0 && Dst6 <= X7, \"Incorrect_Range\");\n static_assert(Dst7 >= X0 && Dst7 <= X7, \"Incorrect_Range\");\n if (Dst0 + X4 == Dst4 && Dst1 + X4 == Dst5 && Dst2 + X4 == Dst6 && Dst3 + X4 == Dst7) {\n return permute(x);\n }\n const __m128 loIn = _mm256_castps256_ps128(x);\n const __m128 hiIn = _mm256_extractf128_ps(x, 1);\n __m128 lo, hi;\n\n if (Dst0 < X4 && Dst1 < X4 && Dst2 < X4 && Dst3 < X4) {\n lo = _mm_permute_ps(loIn, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);\n } else if (Dst0 >= X4 && Dst1 >= X4 && Dst2 >= X4 && Dst3 >= X4) {\n lo = _mm_permute_ps(hiIn, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);\n } else if (Dst0 < X4 && Dst1 < X4 && Dst2 >= X4 && Dst3 >= X4) {\n lo = shuffle(loIn, hiIn);\n } else if (Dst0 >= X4 && Dst1 >= X4 && Dst2 < X4 && Dst3 < X4) {\n lo = shuffle(hiIn, loIn);\n } else if (Dst0 == X0 && Dst1 == X4 && Dst2 == X1 && Dst3 == X5) {\n lo = _mm_unpacklo_ps(loIn, hiIn);\n } else if (Dst0 == X4 && Dst1 == X0 && Dst2 == X5 && Dst3 == X1) {\n lo = _mm_unpacklo_ps(hiIn, loIn);\n } else if (Dst0 == X2 && Dst1 == X6 && Dst2 == X3 && Dst3 == X7) {\n lo = _mm_unpackhi_ps(loIn, hiIn);\n } else if (Dst0 == X6 && Dst1 == X2 && Dst2 == X7 && Dst3 == X3) {\n lo = _mm_unpackhi_ps(hiIn, loIn);\n } else if (Dst0 % X4 == 0 && Dst1 % X4 == 1 && Dst2 % X4 == 2 && Dst3 % X4 == 3) {\n lo = blend::Value, ScaleForBlend::Value,\n ScaleForBlend::Value, ScaleForBlend::Value>(loIn, hiIn);\n }\n\n if (Dst4 >= X4 && Dst5 >= X4 && Dst6 >= X4 && Dst7 >= X4) {\n hi = _mm_permute_ps(hiIn, (Dst4 - X4) + (Dst5 - X4) * 4 + (Dst6 - X4) * 16 + (Dst7 - X4) * 64);\n } else if (Dst4 < X4 && Dst5 < X4 && Dst6 < X4 && Dst7 < X4) {\n hi = _mm_permute_ps(loIn, (Dst4 - X4) + (Dst5 - X4) * 4 + (Dst6 - X4) * 16 + (Dst7 - X4) * 64);\n } else if (Dst4 < X4 && Dst5 < X4 && Dst6 >= X4 && Dst7 >= X4) {\n hi = shuffle(loIn, hiIn);\n } else if (Dst4 >= X4 && Dst5 >= X4 && Dst6 < X4 && Dst7 < X4) {\n hi = shuffle(hiIn, loIn);\n } else if (Dst4 == X0 && Dst5 == X4 && Dst6 == X1 && Dst7 == X5) {\n hi = _mm_unpacklo_ps(loIn, hiIn);\n } else if (Dst4 == X4 && Dst5 == X0 && Dst6 == X5 && Dst7 == X1) {\n hi = _mm_unpacklo_ps(hiIn, loIn);\n } else if (Dst4 == X2 && Dst5 == X6 && Dst6 == X3 && Dst7 == X7) {\n hi = _mm_unpackhi_ps(loIn, hiIn);\n } else if (Dst4 == X6 && Dst5 == X2 && Dst6 == X7 && Dst7 == X3) {\n hi = _mm_unpackhi_ps(hiIn, loIn);\n } else if (Dst4 % X4 == 0 && Dst5 % X4 == 1 && Dst6 % X4 == 2 && Dst7 % X4 == 3) {\n hi = blend::Value, ScaleForBlend::Value,\n ScaleForBlend::Value, ScaleForBlend::Value>(loIn, hiIn);\n }\n\n return _mm256_insertf128_ps(_mm256_castps128_ps256(lo), hi, 1);\n }\n} // namespace Mem\n} // namespace Vc\n\n // little endian has the lo bits on the right and high bits on the left\n // with vectors this becomes greatly confusing:\n // Mem: abcd\n // Reg: dcba\n //\n // The shuffles and permutes above use memory ordering. The ones below use register ordering:\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Reg\n{\n template static Vc_ALWAYS_INLINE __m256 Vc_CONST permute128(__m256 x, __m256 y) {\n static_assert(L >= X0 && H >= X0, \"Incorrect_Range\");\n static_assert(L <= Y1 && H <= Y1, \"Incorrect_Range\");\n return _mm256_permute2f128_ps(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));\n }\n template static Vc_ALWAYS_INLINE __m256i Vc_CONST permute128(__m256i x, __m256i y) {\n static_assert(L >= X0 && H >= X0, \"Incorrect_Range\");\n static_assert(L <= Y1 && H <= Y1, \"Incorrect_Range\");\n#ifdef Vc_IMPL_AVX2\n return _mm256_permute2x128_si256(\n x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));\n#else\n return _mm256_permute2f128_si256(\n x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));\n#endif\n }\n template static Vc_ALWAYS_INLINE __m256d Vc_CONST permute128(__m256d x, __m256d y) {\n static_assert(L >= X0 && H >= X0, \"Incorrect_Range\");\n static_assert(L <= Y1 && H <= Y1, \"Incorrect_Range\");\n return _mm256_permute2f128_pd(x, y, (L < Y0 ? L : L - Y0 + 2) + (H < Y0 ? H : H - Y0 + 2) * (1 << 4));\n }\n template static Vc_ALWAYS_INLINE __m256d Vc_CONST permute(__m256d x) {\n static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X2 && Dst3 >= X2, \"Incorrect_Range\");\n static_assert(Dst0 <= X1 && Dst1 <= X1 && Dst2 <= X3 && Dst3 <= X3, \"Incorrect_Range\");\n return _mm256_permute_pd(x, Dst0 + Dst1 * 2 + (Dst2 - X2) * 4 + (Dst3 - X2) * 8);\n }\n template static Vc_ALWAYS_INLINE __m256 Vc_CONST permute(__m256 x) {\n static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, \"Incorrect_Range\");\n static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, \"Incorrect_Range\");\n return _mm256_permute_ps(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);\n }\n template static Vc_ALWAYS_INLINE __m128d Vc_CONST permute(__m128d x) {\n static_assert(Dst0 >= X0 && Dst1 >= X0, \"Incorrect_Range\");\n static_assert(Dst0 <= X1 && Dst1 <= X1, \"Incorrect_Range\");\n return _mm_permute_pd(x, Dst0 + Dst1 * 2);\n }\n template static Vc_ALWAYS_INLINE __m128 Vc_CONST permute(__m128 x) {\n static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= X0 && Dst3 >= X0, \"Incorrect_Range\");\n static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= X3 && Dst3 <= X3, \"Incorrect_Range\");\n return _mm_permute_ps(x, Dst0 + Dst1 * 4 + Dst2 * 16 + Dst3 * 64);\n }\n template static Vc_ALWAYS_INLINE __m256d Vc_CONST shuffle(__m256d x, __m256d y) {\n static_assert(Dst0 >= X0 && Dst1 >= Y0 && Dst2 >= X2 && Dst3 >= Y2, \"Incorrect_Range\");\n static_assert(Dst0 <= X1 && Dst1 <= Y1 && Dst2 <= X3 && Dst3 <= Y3, \"Incorrect_Range\");\n return _mm256_shuffle_pd(x, y, Dst0 + (Dst1 - Y0) * 2 + (Dst2 - X2) * 4 + (Dst3 - Y2) * 8);\n }\n template static Vc_ALWAYS_INLINE __m256 Vc_CONST shuffle(__m256 x, __m256 y) {\n static_assert(Dst0 >= X0 && Dst1 >= X0 && Dst2 >= Y0 && Dst3 >= Y0, \"Incorrect_Range\");\n static_assert(Dst0 <= X3 && Dst1 <= X3 && Dst2 <= Y3 && Dst3 <= Y3, \"Incorrect_Range\");\n return _mm256_shuffle_ps(x, y, Dst0 + Dst1 * 4 + (Dst2 - Y0) * 16 + (Dst3 - Y0) * 64);\n }\n} // namespace Reg\n} // namespace Vc\n\n#endif // VC_AVX_SHUFFLE_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/simd_cast.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_SIMD_CAST_H_\n#define VC_AVX_SIMD_CAST_H_\n\n#ifndef VC_AVX_VECTOR_H_\n#error \"Vc/avx/vector.h needs to be included before Vc/avx/simd_cast.h\"\n#endif\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n// Declarations: helper macros Vc_SIMD_CAST_AVX_[124] & Vc_SIMD_CAST_[124] {{{1\n#define Vc_SIMD_CAST_AVX_1(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n AVX2::from_ x, enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_AVX_2(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n AVX2::from_ x0, AVX2::from_ x1, \\\n enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_AVX_3(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n AVX2::from_ x0, AVX2::from_ x1, AVX2::from_ x2, \\\n enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_AVX_4(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n AVX2::from_ x0, AVX2::from_ x1, AVX2::from_ x2, AVX2::from_ x3, \\\n enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_1(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x, enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_2(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x0, from_ x1, enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_3(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x0, from_ x1, from_ x2, enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_4(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x0, from_ x1, from_ x2, from_ x3, \\\n enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_5(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \\\n enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_6(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, from_ x5, \\\n enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_7(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, from_ x5, from_ x6, \\\n enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_8(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, from_ x5, from_ x6, from_ x7, \\\n enable_if::value> = nullarg)\n\n#define Vc_SIMD_CAST_OFFSET(from_, to_, offset_) \\\n static_assert(from_::size() >= to_::size() * (offset_ + 1), \\\n \"this offset cannot exist for this type combination\"); \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x, \\\n enable_if<(offset == offset_ && std::is_same::value)> = nullarg)\n\n// Declaration: SSE -> AVX where the AVX Vector is integral and thus of equal size() {{{1\n// as the equivalent SSE Vector\ntemplate \nVc_INTRINSIC Vc_CONST To\nsimd_cast(From x, enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)> =\n nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST To simd_cast(\n From x0, From x1,\n enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST To simd_cast(\n From x0, From x1, From x2,\n enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST To simd_cast(\n From x0, From x1, From x2, From x3,\n enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST To simd_cast(\n From x0, From x1, From x2, From x3, From x4, From x5, From x6, From x7,\n enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)> = nullarg);\n\n// Declarations: Vector casts without offset {{{1\n// AVX2::Vector {{{2\nVc_SIMD_CAST_AVX_1( float_v, double_v);\n\nVc_SIMD_CAST_AVX_1(double_v, float_v);\nVc_SIMD_CAST_AVX_2(double_v, float_v);\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_1( int_v, double_v);\nVc_SIMD_CAST_AVX_1( uint_v, double_v);\nVc_SIMD_CAST_AVX_1( short_v, double_v);\nVc_SIMD_CAST_AVX_1(ushort_v, double_v);\n\nVc_SIMD_CAST_AVX_1( int_v, float_v);\nVc_SIMD_CAST_AVX_1( uint_v, float_v);\nVc_SIMD_CAST_AVX_1( short_v, float_v);\nVc_SIMD_CAST_AVX_1(ushort_v, float_v);\n\nVc_SIMD_CAST_AVX_1(double_v, int_v);\nVc_SIMD_CAST_AVX_1( float_v, int_v);\nVc_SIMD_CAST_AVX_1( uint_v, int_v);\nVc_SIMD_CAST_AVX_1( short_v, int_v);\nVc_SIMD_CAST_AVX_1(ushort_v, int_v);\nVc_SIMD_CAST_AVX_2(double_v, int_v);\n\nVc_SIMD_CAST_AVX_1(double_v, uint_v);\nVc_SIMD_CAST_AVX_1( float_v, uint_v);\nVc_SIMD_CAST_AVX_1( int_v, uint_v);\nVc_SIMD_CAST_AVX_1( short_v, uint_v);\nVc_SIMD_CAST_AVX_1(ushort_v, uint_v);\nVc_SIMD_CAST_AVX_2(double_v, uint_v);\n\nVc_SIMD_CAST_AVX_1(double_v, short_v);\nVc_SIMD_CAST_AVX_1( float_v, short_v);\nVc_SIMD_CAST_AVX_1( int_v, short_v);\nVc_SIMD_CAST_AVX_1( uint_v, short_v);\nVc_SIMD_CAST_AVX_1(ushort_v, short_v);\nVc_SIMD_CAST_AVX_2(double_v, short_v);\nVc_SIMD_CAST_AVX_2( float_v, short_v);\nVc_SIMD_CAST_AVX_2( int_v, short_v);\nVc_SIMD_CAST_AVX_2( uint_v, short_v);\nVc_SIMD_CAST_AVX_3(double_v, short_v);\nVc_SIMD_CAST_AVX_4(double_v, short_v);\n\nVc_SIMD_CAST_AVX_1(double_v, ushort_v);\nVc_SIMD_CAST_AVX_1( float_v, ushort_v);\nVc_SIMD_CAST_AVX_1( int_v, ushort_v);\nVc_SIMD_CAST_AVX_1( uint_v, ushort_v);\nVc_SIMD_CAST_AVX_1( short_v, ushort_v);\nVc_SIMD_CAST_AVX_2(double_v, ushort_v);\nVc_SIMD_CAST_AVX_2( float_v, ushort_v);\nVc_SIMD_CAST_AVX_2( int_v, ushort_v);\nVc_SIMD_CAST_AVX_2( uint_v, ushort_v);\nVc_SIMD_CAST_AVX_3(double_v, ushort_v);\nVc_SIMD_CAST_AVX_4(double_v, ushort_v);\n#endif\n\n// 1 SSE::Vector to 1 AVX2::Vector {{{2\nVc_SIMD_CAST_1(SSE::double_v, AVX2::double_v);\nVc_SIMD_CAST_1(SSE:: float_v, AVX2::double_v);\nVc_SIMD_CAST_1(SSE:: int_v, AVX2::double_v);\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2::double_v);\nVc_SIMD_CAST_1(SSE:: short_v, AVX2::double_v);\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2::double_v);\n\nVc_SIMD_CAST_1(SSE::double_v, AVX2:: float_v);\nVc_SIMD_CAST_1(SSE:: float_v, AVX2:: float_v);\nVc_SIMD_CAST_1(SSE:: int_v, AVX2:: float_v);\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2:: float_v);\nVc_SIMD_CAST_1(SSE:: short_v, AVX2:: float_v);\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2:: float_v);\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(SSE::double_v, AVX2:: int_v);\nVc_SIMD_CAST_1(SSE::double_v, AVX2:: uint_v);\nVc_SIMD_CAST_1(SSE::double_v, AVX2:: short_v);\nVc_SIMD_CAST_1(SSE::double_v, AVX2::ushort_v);\n\nVc_SIMD_CAST_1(SSE:: float_v, AVX2:: int_v);\nVc_SIMD_CAST_1(SSE:: float_v, AVX2:: uint_v);\nVc_SIMD_CAST_1(SSE:: float_v, AVX2:: short_v);\nVc_SIMD_CAST_1(SSE:: float_v, AVX2::ushort_v);\n\nVc_SIMD_CAST_1(SSE:: int_v, AVX2:: int_v);\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2:: int_v);\nVc_SIMD_CAST_1(SSE:: short_v, AVX2:: int_v);\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2:: int_v);\n\nVc_SIMD_CAST_1(SSE:: int_v, AVX2:: uint_v);\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2:: uint_v);\nVc_SIMD_CAST_1(SSE:: short_v, AVX2:: uint_v);\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2:: uint_v);\n\nVc_SIMD_CAST_1(SSE:: int_v, AVX2:: short_v);\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2:: short_v);\nVc_SIMD_CAST_1(SSE:: short_v, AVX2:: short_v);\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2:: short_v);\n\nVc_SIMD_CAST_1(SSE:: int_v, AVX2::ushort_v);\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2::ushort_v);\nVc_SIMD_CAST_1(SSE:: short_v, AVX2::ushort_v);\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2::ushort_v);\n#endif\n\n// 2 SSE::Vector to 1 AVX2::Vector {{{2\nVc_SIMD_CAST_2(SSE::double_v, AVX2::double_v);\n\nVc_SIMD_CAST_2(SSE::double_v, AVX2:: float_v);\nVc_SIMD_CAST_2(SSE:: float_v, AVX2:: float_v);\nVc_SIMD_CAST_2(SSE:: int_v, AVX2:: float_v);\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2:: float_v);\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_2(SSE::double_v, AVX2:: int_v);\nVc_SIMD_CAST_2(SSE::double_v, AVX2:: uint_v);\nVc_SIMD_CAST_2(SSE::double_v, AVX2:: short_v);\nVc_SIMD_CAST_2(SSE::double_v, AVX2::ushort_v);\n\nVc_SIMD_CAST_2(SSE:: float_v, AVX2:: int_v);\nVc_SIMD_CAST_2(SSE:: float_v, AVX2:: uint_v);\nVc_SIMD_CAST_2(SSE:: float_v, AVX2:: short_v);\nVc_SIMD_CAST_2(SSE:: float_v, AVX2::ushort_v);\n\nVc_SIMD_CAST_2(SSE:: int_v, AVX2:: int_v);\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2:: int_v);\n\nVc_SIMD_CAST_2(SSE:: int_v, AVX2:: uint_v);\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2:: uint_v);\n\nVc_SIMD_CAST_2(SSE:: int_v, AVX2:: short_v);\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2:: short_v);\nVc_SIMD_CAST_2(SSE:: short_v, AVX2:: short_v);\nVc_SIMD_CAST_2(SSE::ushort_v, AVX2:: short_v);\n\nVc_SIMD_CAST_2(SSE:: int_v, AVX2::ushort_v);\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2::ushort_v);\nVc_SIMD_CAST_2(SSE:: short_v, AVX2::ushort_v);\nVc_SIMD_CAST_2(SSE::ushort_v, AVX2::ushort_v);\n#endif\n\n// 3 SSE::Vector to 1 AVX2::Vector {{{2\nVc_SIMD_CAST_3(SSE::double_v, AVX2:: float_v);\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_3(SSE::double_v, AVX2:: int_v);\nVc_SIMD_CAST_3(SSE::double_v, AVX2:: uint_v);\nVc_SIMD_CAST_3(SSE::double_v, AVX2:: short_v);\nVc_SIMD_CAST_3(SSE::double_v, AVX2::ushort_v);\n\nVc_SIMD_CAST_3(SSE:: float_v, AVX2:: short_v);\nVc_SIMD_CAST_3(SSE:: float_v, AVX2::ushort_v);\n\nVc_SIMD_CAST_3(SSE:: int_v, AVX2:: short_v);\nVc_SIMD_CAST_3(SSE:: uint_v, AVX2:: short_v);\n\nVc_SIMD_CAST_3(SSE:: int_v, AVX2::ushort_v);\nVc_SIMD_CAST_3(SSE:: uint_v, AVX2::ushort_v);\n#endif\n\n// 4 SSE::Vector to 1 AVX2::Vector {{{2\nVc_SIMD_CAST_4(SSE::double_v, AVX2:: float_v);\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_4(SSE::double_v, AVX2:: int_v);\nVc_SIMD_CAST_4(SSE::double_v, AVX2:: uint_v);\nVc_SIMD_CAST_4(SSE::double_v, AVX2:: short_v);\nVc_SIMD_CAST_4(SSE::double_v, AVX2::ushort_v);\n\nVc_SIMD_CAST_4(SSE:: float_v, AVX2:: short_v);\nVc_SIMD_CAST_4(SSE:: float_v, AVX2::ushort_v);\n\nVc_SIMD_CAST_4(SSE:: int_v, AVX2:: short_v);\nVc_SIMD_CAST_4(SSE:: uint_v, AVX2:: short_v);\n\nVc_SIMD_CAST_4(SSE:: int_v, AVX2::ushort_v);\nVc_SIMD_CAST_4(SSE:: uint_v, AVX2::ushort_v);\n#endif\n\n// 5 SSE::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_5(SSE::double_v, AVX2:: short_v);\nVc_SIMD_CAST_5(SSE::double_v, AVX2::ushort_v);\n#endif\n\n// 6 SSE::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_6(SSE::double_v, AVX2:: short_v);\nVc_SIMD_CAST_6(SSE::double_v, AVX2::ushort_v);\n#endif\n\n// 7 SSE::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_7(SSE::double_v, AVX2:: short_v);\nVc_SIMD_CAST_7(SSE::double_v, AVX2::ushort_v);\n#endif\n\n// 8 SSE::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_8(SSE::double_v, AVX2:: short_v);\nVc_SIMD_CAST_8(SSE::double_v, AVX2::ushort_v);\n#endif\n\n// 1 AVX2::Vector to 1 SSE::Vector {{{2\nVc_SIMD_CAST_1(AVX2::double_v, SSE::double_v);\nVc_SIMD_CAST_1(AVX2::double_v, SSE:: float_v);\nVc_SIMD_CAST_1(AVX2::double_v, SSE:: int_v);\nVc_SIMD_CAST_1(AVX2::double_v, SSE:: uint_v);\nVc_SIMD_CAST_1(AVX2::double_v, SSE:: short_v);\nVc_SIMD_CAST_1(AVX2::double_v, SSE::ushort_v);\n\nVc_SIMD_CAST_1(AVX2:: float_v, SSE::double_v);\nVc_SIMD_CAST_1(AVX2:: float_v, SSE:: float_v);\nVc_SIMD_CAST_1(AVX2:: float_v, SSE:: int_v);\nVc_SIMD_CAST_1(AVX2:: float_v, SSE:: uint_v);\nVc_SIMD_CAST_1(AVX2:: float_v, SSE:: short_v);\nVc_SIMD_CAST_1(AVX2:: float_v, SSE::ushort_v);\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(AVX2:: int_v, SSE::double_v);\nVc_SIMD_CAST_1(AVX2:: int_v, SSE:: float_v);\nVc_SIMD_CAST_1(AVX2:: int_v, SSE:: uint_v);\nVc_SIMD_CAST_1(AVX2:: int_v, SSE:: int_v);\nVc_SIMD_CAST_1(AVX2:: int_v, SSE:: short_v);\nVc_SIMD_CAST_1(AVX2:: int_v, SSE::ushort_v);\n\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE::double_v);\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE:: float_v);\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE:: int_v);\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE:: uint_v);\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE:: short_v);\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE::ushort_v);\n\nVc_SIMD_CAST_1(AVX2:: short_v, SSE::double_v);\nVc_SIMD_CAST_1(AVX2:: short_v, SSE:: float_v);\nVc_SIMD_CAST_1(AVX2:: short_v, SSE:: int_v);\nVc_SIMD_CAST_1(AVX2:: short_v, SSE:: uint_v);\nVc_SIMD_CAST_1(AVX2:: short_v, SSE:: short_v);\nVc_SIMD_CAST_1(AVX2:: short_v, SSE::ushort_v);\n\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE::double_v);\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE:: float_v);\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE:: int_v);\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE:: uint_v);\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE:: short_v);\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE::ushort_v);\n#endif\n\n// 2 AVX2::Vector to 1 SSE::Vector {{{2\nVc_SIMD_CAST_2(AVX2::double_v, SSE:: short_v);\nVc_SIMD_CAST_2(AVX2::double_v, SSE::ushort_v);\n\n// 1 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value> = nullarg);\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value> = nullarg);\n#endif\n\n// 2 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value> = nullarg);\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value> = nullarg);\n#endif\n\n// 3 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value> = nullarg);\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value> = nullarg);\n#endif\n\n// 4 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value> = nullarg);\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value> = nullarg);\n#endif\n\n// 5 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value> = nullarg);\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value> = nullarg);\n#endif\n\n// 6 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value> = nullarg);\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value> = nullarg);\n#endif\n\n// 7 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value> = nullarg);\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value> = nullarg);\n#endif\n\n// 8 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value> = nullarg);\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value> = nullarg);\n#endif\n\n// 9 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n enable_if::value> = nullarg);\n#endif\n\n// 10 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9,\n enable_if::value> = nullarg);\n#endif\n\n// 11 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10,\n enable_if::value> = nullarg);\n#endif\n\n// 12 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n enable_if::value> = nullarg);\n#endif\n\n// 13 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12,\n enable_if::value> = nullarg);\n#endif\n\n// 14 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13,\n enable_if::value> = nullarg);\n#endif\n\n// 15 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13, Scalar::Vector x14,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13, Scalar::Vector x14,\n enable_if::value> = nullarg);\n#endif\n\n// 16 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13, Scalar::Vector x14,\n Scalar::Vector x15,\n enable_if::value> = nullarg);\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13, Scalar::Vector x14,\n Scalar::Vector x15,\n enable_if::value> = nullarg);\n#endif\n\n// 1 AVX2::Vector to 1 Scalar::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST To simd_cast(AVX2::Vector x,\n enable_if::value> = nullarg);\n\n// Declarations: Mask casts without offset {{{1\n// 1 AVX2::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\n simd_cast(const AVX2::Mask &k, enable_if::value> = nullarg);\n\n// 2 AVX2::Mask to 1 AVX2::Mask {{{2\nVc_SIMD_CAST_AVX_2(double_m, float_m);\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_2(double_m, int_m);\nVc_SIMD_CAST_AVX_2(double_m, uint_m);\nVc_SIMD_CAST_AVX_2(double_m, short_m);\nVc_SIMD_CAST_AVX_2(double_m, ushort_m);\n\nVc_SIMD_CAST_AVX_2( float_m, short_m);\nVc_SIMD_CAST_AVX_2( float_m, ushort_m);\n\nVc_SIMD_CAST_AVX_2( int_m, short_m);\nVc_SIMD_CAST_AVX_2( int_m, ushort_m);\n\nVc_SIMD_CAST_AVX_2( uint_m, short_m);\nVc_SIMD_CAST_AVX_2( uint_m, ushort_m);\n#endif\n\n// 4 AVX2::Mask to 1 AVX2::Mask {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_4(double_m, short_m);\nVc_SIMD_CAST_AVX_4(double_m, ushort_m);\n#endif\n\n// 1 SSE::Mask to 1 AVX2::Mask {{{2\nVc_SIMD_CAST_1(SSE::double_m, AVX2::double_m);\nVc_SIMD_CAST_1(SSE::double_m, AVX2:: float_m);\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(SSE::double_m, AVX2:: int_m);\nVc_SIMD_CAST_1(SSE::double_m, AVX2:: uint_m);\nVc_SIMD_CAST_1(SSE::double_m, AVX2:: short_m);\nVc_SIMD_CAST_1(SSE::double_m, AVX2::ushort_m);\n#endif\n\nVc_SIMD_CAST_1(SSE:: float_m, AVX2::double_m);\nVc_SIMD_CAST_1(SSE:: int_m, AVX2::double_m);\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2::double_m);\nVc_SIMD_CAST_1(SSE:: short_m, AVX2::double_m);\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2::double_m);\n\nVc_SIMD_CAST_1(SSE:: float_m, AVX2:: float_m);\nVc_SIMD_CAST_1(SSE:: int_m, AVX2:: float_m);\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2:: float_m);\nVc_SIMD_CAST_1(SSE:: short_m, AVX2:: float_m);\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2:: float_m);\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(SSE:: float_m, AVX2:: int_m);\nVc_SIMD_CAST_1(SSE:: float_m, AVX2:: uint_m);\nVc_SIMD_CAST_1(SSE:: int_m, AVX2:: int_m);\nVc_SIMD_CAST_1(SSE:: int_m, AVX2:: uint_m);\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2:: int_m);\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2:: uint_m);\n\nVc_SIMD_CAST_1(SSE:: float_m, AVX2:: short_m);\nVc_SIMD_CAST_1(SSE:: int_m, AVX2:: short_m);\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2:: short_m);\nVc_SIMD_CAST_1(SSE:: short_m, AVX2:: short_m);\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2:: short_m);\nVc_SIMD_CAST_1(SSE:: float_m, AVX2::ushort_m);\nVc_SIMD_CAST_1(SSE:: int_m, AVX2::ushort_m);\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2::ushort_m);\nVc_SIMD_CAST_1(SSE:: short_m, AVX2::ushort_m);\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2::ushort_m);\n\nVc_SIMD_CAST_1(SSE:: short_m, AVX2:: int_m);\nVc_SIMD_CAST_1(SSE:: short_m, AVX2:: uint_m);\n\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2:: int_m);\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2:: uint_m);\n#endif\n\n// 2 SSE::Mask to 1 AVX2::Mask {{{2\nVc_SIMD_CAST_2(SSE::double_m, AVX2::double_m);\nVc_SIMD_CAST_2(SSE::double_m, AVX2:: float_m);\nVc_SIMD_CAST_2(SSE:: float_m, AVX2:: float_m);\nVc_SIMD_CAST_2(SSE:: int_m, AVX2:: float_m);\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2:: float_m);\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_2(SSE::double_m, AVX2:: int_m);\nVc_SIMD_CAST_2(SSE::double_m, AVX2:: uint_m);\nVc_SIMD_CAST_2(SSE::double_m, AVX2:: short_m);\nVc_SIMD_CAST_2(SSE::double_m, AVX2::ushort_m);\n\nVc_SIMD_CAST_2(SSE:: float_m, AVX2:: int_m);\nVc_SIMD_CAST_2(SSE:: float_m, AVX2:: uint_m);\nVc_SIMD_CAST_2(SSE:: float_m, AVX2:: short_m);\nVc_SIMD_CAST_2(SSE:: float_m, AVX2::ushort_m);\n\nVc_SIMD_CAST_2(SSE:: int_m, AVX2:: int_m);\nVc_SIMD_CAST_2(SSE:: int_m, AVX2:: uint_m);\nVc_SIMD_CAST_2(SSE:: int_m, AVX2:: short_m);\nVc_SIMD_CAST_2(SSE:: int_m, AVX2::ushort_m);\n\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2:: int_m);\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2:: uint_m);\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2:: short_m);\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2::ushort_m);\n\nVc_SIMD_CAST_2(SSE:: short_m, AVX2:: short_m);\nVc_SIMD_CAST_2(SSE:: short_m, AVX2::ushort_m);\nVc_SIMD_CAST_2(SSE::ushort_m, AVX2:: short_m);\nVc_SIMD_CAST_2(SSE::ushort_m, AVX2::ushort_m);\n#endif\n\n// 4 SSE::Mask to 1 AVX2::Mask {{{2\nVc_SIMD_CAST_4(SSE::double_m, AVX2:: float_m);\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_4(SSE::double_m, AVX2:: int_m);\nVc_SIMD_CAST_4(SSE::double_m, AVX2:: uint_m);\nVc_SIMD_CAST_4(SSE::double_m, AVX2:: short_m);\nVc_SIMD_CAST_4(SSE::double_m, AVX2::ushort_m);\nVc_SIMD_CAST_4(SSE:: float_m, AVX2:: short_m);\nVc_SIMD_CAST_4(SSE:: float_m, AVX2::ushort_m);\nVc_SIMD_CAST_4(SSE:: int_m, AVX2:: short_m);\nVc_SIMD_CAST_4(SSE:: int_m, AVX2::ushort_m);\nVc_SIMD_CAST_4(SSE:: uint_m, AVX2:: short_m);\nVc_SIMD_CAST_4(SSE:: uint_m, AVX2::ushort_m);\n#endif\n\n// 1 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Mask k,\n enable_if::value> = nullarg);\n\n// 2 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Mask k0, Scalar::Mask k1,\n enable_if::value> = nullarg);\n\n// 4 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return simd_cast(\n Scalar::Mask k0, Scalar::Mask k1, Scalar::Mask k2, Scalar::Mask k3,\n enable_if<(AVX2::is_mask::value && Return::Size >= 4)> = nullarg);\n\n// 8 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return simd_cast(\n Scalar::Mask k0, Scalar::Mask k1, Scalar::Mask k2, Scalar::Mask k3,\n Scalar::Mask k4, Scalar::Mask k5, Scalar::Mask k6, Scalar::Mask k7,\n enable_if<(AVX2::is_mask::value && Return::Size >= 8)> = nullarg);\n\n// 16 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Mask k0, Scalar::Mask k1, Scalar::Mask k2, Scalar::Mask k3,\n Scalar::Mask k4, Scalar::Mask k5, Scalar::Mask k6, Scalar::Mask k7,\n Scalar::Mask k8, Scalar::Mask k9, Scalar::Mask k10,\n Scalar::Mask k11, Scalar::Mask k12, Scalar::Mask k13,\n Scalar::Mask k14, Scalar::Mask k15,\n enable_if<(AVX2::is_mask::value && Return::Size >= 16)> = nullarg);\n\n// 1 AVX2::Mask to 1 SSE::Mask {{{2\nVc_SIMD_CAST_1(AVX2::double_m, SSE::double_m);\nVc_SIMD_CAST_1(AVX2::double_m, SSE:: float_m);\nVc_SIMD_CAST_1(AVX2::double_m, SSE:: int_m);\nVc_SIMD_CAST_1(AVX2::double_m, SSE:: uint_m);\nVc_SIMD_CAST_1(AVX2::double_m, SSE:: short_m);\nVc_SIMD_CAST_1(AVX2::double_m, SSE::ushort_m);\n\nVc_SIMD_CAST_1(AVX2:: float_m, SSE::double_m);\nVc_SIMD_CAST_1(AVX2:: float_m, SSE:: float_m);\nVc_SIMD_CAST_1(AVX2:: float_m, SSE:: int_m);\nVc_SIMD_CAST_1(AVX2:: float_m, SSE:: uint_m);\nVc_SIMD_CAST_1(AVX2:: float_m, SSE:: short_m);\nVc_SIMD_CAST_1(AVX2:: float_m, SSE::ushort_m);\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(AVX2:: int_m, SSE::double_m);\nVc_SIMD_CAST_1(AVX2:: int_m, SSE:: float_m);\nVc_SIMD_CAST_1(AVX2:: int_m, SSE:: int_m);\nVc_SIMD_CAST_1(AVX2:: int_m, SSE:: uint_m);\nVc_SIMD_CAST_1(AVX2:: int_m, SSE:: short_m);\nVc_SIMD_CAST_1(AVX2:: int_m, SSE::ushort_m);\n\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE::double_m);\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE:: float_m);\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE:: int_m);\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE:: uint_m);\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE:: short_m);\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE::ushort_m);\n\nVc_SIMD_CAST_1(AVX2:: short_m, SSE::double_m);\nVc_SIMD_CAST_1(AVX2:: short_m, SSE:: float_m);\nVc_SIMD_CAST_1(AVX2:: short_m, SSE:: int_m);\nVc_SIMD_CAST_1(AVX2:: short_m, SSE:: uint_m);\nVc_SIMD_CAST_1(AVX2:: short_m, SSE:: short_m);\nVc_SIMD_CAST_1(AVX2:: short_m, SSE::ushort_m);\n\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE::double_m);\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE:: float_m);\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE:: int_m);\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE:: uint_m);\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE:: short_m);\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE::ushort_m);\n#endif\n\n// 2 AVX2::Mask to 1 SSE::Mask {{{2\nVc_SIMD_CAST_2(AVX2::double_m, SSE:: short_m);\nVc_SIMD_CAST_2(AVX2::double_m, SSE::ushort_m);\n\n// 1 AVX2::Mask to 1 Scalar::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST To simd_cast(AVX2::Mask x,\n enable_if::value> = nullarg);\n\n// Declaration: offset == 0 | convert from AVX2::Mask/Vector {{{1\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<\n (offset == 0 &&\n ((AVX2::is_vector::value && !Scalar::is_vector::value &&\n Traits::is_simd_vector::value && !Traits::isSimdArray::value) ||\n (AVX2::is_mask::value && !Scalar::is_mask::value &&\n Traits::is_simd_mask::value &&\n !Traits::isSimdMaskArray::value))),\n Return>\nsimd_cast(const From &x);\n// Declaration: offset == 0 | convert from SSE::Mask/Vector to AVX2::Mask/Vector {{{1\ntemplate \nVc_INTRINSIC Vc_CONST Return simd_cast(\n const From &x,\n enable_if::value &&\n AVX2::is_vector::value) ||\n (SSE::is_mask::value &&\n AVX2::is_mask::value))> = nullarg);\n\n// Declarations: Vector casts with offset {{{1\n// AVX2 to AVX2 {{{2\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(AVX2::is_vector::value && offset != 0),\n Return>\nsimd_cast(AVX2::Vector x);\n// AVX2 to SSE (Vector) {{{2\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_vector::value &&\n sizeof(AVX2::Vector) == 32),\n Return>\nsimd_cast(AVX2::Vector x);\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_vector::value &&\n sizeof(AVX2::Vector) == 16),\n Return>\nsimd_cast(AVX2::Vector x);\n// SSE to AVX2 {{{2\nVc_SIMD_CAST_OFFSET(SSE:: short_v, AVX2::double_v, 1);\nVc_SIMD_CAST_OFFSET(SSE::ushort_v, AVX2::double_v, 1);\n\n// Declarations: Mask casts with offset {{{1\n// 1 AVX2::Mask to N AVX2::Mask {{{2\n/* This declaration confuses GCC (4.9.2). If the declarations are there the definitions\n * are ignored by the compiler. ;-(\ntemplate \nVc_INTRINSIC_L Vc_CONST_L Return\nsimd_cast(const AVX2::Mask &k,\n enable_if::value> = nullarg) Vc_INTRINSIC_R Vc_CONST_R;\ntemplate \nVc_INTRINSIC_L Vc_CONST_L Return\nsimd_cast(const AVX2::Mask &k,\n enable_if::value> = nullarg) Vc_INTRINSIC_R Vc_CONST_R;\ntemplate \nVc_INTRINSIC_L Vc_CONST_L Return\nsimd_cast(const AVX2::Mask &k,\n enable_if::value> = nullarg) Vc_INTRINSIC_R Vc_CONST_R;\ntemplate \nVc_INTRINSIC_L Vc_CONST_L Return\nsimd_cast(const AVX2::Mask &k,\n enable_if::value> = nullarg) Vc_INTRINSIC_R Vc_CONST_R;\n */\n\n// 1 SSE::Mask to N AVX2(2)::Mask {{{2\nVc_SIMD_CAST_OFFSET(SSE:: short_m, AVX2::double_m, 1);\nVc_SIMD_CAST_OFFSET(SSE::ushort_m, AVX2::double_m, 1);\n\n// AVX2 to SSE (Mask) {{{2\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_mask::value &&\n sizeof(AVX2::Mask) == 32),\n Return>\nsimd_cast(AVX2::Mask x);\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_mask::value &&\n sizeof(AVX2::Mask) == 16),\n Return>\nsimd_cast(AVX2::Mask x);\n\n// helper macros Vc_SIMD_CAST_AVX_[124] & Vc_SIMD_CAST_[124] {{{1\n#undef Vc_SIMD_CAST_AVX_1\n#define Vc_SIMD_CAST_AVX_1(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::from_ x, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_AVX_2\n#define Vc_SIMD_CAST_AVX_2(from_, to_) \\\n static_assert(AVX2::from_::size() * 2 <= AVX2::to_::size(), \\\n \"this type combination is wrong\"); \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::from_ x0, AVX2::from_ x1, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_AVX_3\n#define Vc_SIMD_CAST_AVX_3(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::from_ x0, AVX2::from_ x1, AVX2::from_ x2, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_AVX_4\n#define Vc_SIMD_CAST_AVX_4(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(AVX2::from_ x0, AVX2::from_ x1, AVX2::from_ x2, \\\n AVX2::from_ x3, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_1\n#define Vc_SIMD_CAST_1(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(from_ x, enable_if::value>)\n\n#undef Vc_SIMD_CAST_2\n#define Vc_SIMD_CAST_2(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_3\n#define Vc_SIMD_CAST_3(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_4\n#define Vc_SIMD_CAST_4(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_5\n#define Vc_SIMD_CAST_5(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_6\n#define Vc_SIMD_CAST_6(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \\\n from_ x5, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_7\n#define Vc_SIMD_CAST_7(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \\\n from_ x5, from_ x6, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_8\n#define Vc_SIMD_CAST_8(from_, to_) \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast(from_ x0, from_ x1, from_ x2, from_ x3, from_ x4, \\\n from_ x5, from_ x6, from_ x7, \\\n enable_if::value>)\n\n#undef Vc_SIMD_CAST_OFFSET\n#define Vc_SIMD_CAST_OFFSET(from_, to_, offset_) \\\n static_assert(from_::size() >= to_::size() * (offset_ + 1), \\\n \"this offset cannot exist for this type combination\"); \\\n template \\\n Vc_INTRINSIC Vc_CONST To simd_cast( \\\n from_ x, enable_if<(offset == offset_ && std::is_same::value)>)\n\n// SSE -> AVX2 where the AVX2 Vector is integral and thus of equal size() as the {{{1\n// equivalent SSE Vector\ntemplate \nVc_INTRINSIC Vc_CONST To\nsimd_cast(From x, enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)>)\n{\n return simd_cast>(x).data();\n}\ntemplate \nVc_INTRINSIC Vc_CONST To\nsimd_cast(From x0, From x1,\n enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)>)\n{\n return simd_cast>(x0, x1).data();\n}\ntemplate \nVc_INTRINSIC Vc_CONST To\nsimd_cast(From x0, From x1, From x2,\n enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)>)\n{\n return simd_cast>(x0, x1, x2).data();\n}\ntemplate \nVc_INTRINSIC Vc_CONST To\nsimd_cast(From x0, From x1, From x2, From x3,\n enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)>)\n{\n return simd_cast>(x0, x1, x2, x3).data();\n}\ntemplate \nVc_INTRINSIC Vc_CONST To\nsimd_cast(From x0, From x1, From x2, From x3, From x4, From x5, From x6, From x7,\n enable_if<(AVX2::is_vector::value && SSE::is_vector::value &&\n SSE::Vector::Size == To::Size)>)\n{\n return simd_cast>(x0, x1, x2, x3, x4, x5, x6, x7)\n .data();\n}\n\n// Vector casts without offset {{{1\n// AVX2::Vector {{{2\n// 1: to double_v {{{3\nVc_SIMD_CAST_AVX_1( float_v, double_v) { return _mm256_cvtps_pd(AVX::lo128(x.data())); }\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_1( int_v, double_v) { return AVX::convert< int, double>(AVX::lo128(x.data())); }\nVc_SIMD_CAST_AVX_1( uint_v, double_v) { return AVX::convert< uint, double>(AVX::lo128(x.data())); }\nVc_SIMD_CAST_AVX_1( short_v, double_v) { return AVX::convert< short, double>(AVX::lo128(x.data())); }\nVc_SIMD_CAST_AVX_1(ushort_v, double_v) { return AVX::convert(AVX::lo128(x.data())); }\n#endif\n\n// 1: to float_v {{{3\nVc_SIMD_CAST_AVX_1(double_v, float_v) { return AVX::zeroExtend(_mm256_cvtpd_ps(x.data())); }\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_1( int_v, float_v) { return AVX::convert< int, float>(x.data()); }\nVc_SIMD_CAST_AVX_1( uint_v, float_v) { return AVX::convert< uint, float>(x.data()); }\nVc_SIMD_CAST_AVX_1( short_v, float_v) { return AVX::convert< short, float>(AVX::lo128(x.data())); }\nVc_SIMD_CAST_AVX_1(ushort_v, float_v) { return AVX::convert(AVX::lo128(x.data())); }\n#endif\n\n// 2: to float_v {{{3\nVc_SIMD_CAST_AVX_2(double_v, float_v) { return AVX::concat(_mm256_cvtpd_ps(x0.data()), _mm256_cvtpd_ps(x1.data())); }\n\n// 1: to int_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_1(double_v, int_v) { return AVX::zeroExtend(_mm256_cvttpd_epi32(x.data())); }\nVc_SIMD_CAST_AVX_1( float_v, int_v) { return _mm256_cvttps_epi32(x.data()); }\nVc_SIMD_CAST_AVX_1( uint_v, int_v) { return x.data(); }\nVc_SIMD_CAST_AVX_1( short_v, int_v) { return _mm256_cvtepi16_epi32(AVX::lo128(x.data())); }\nVc_SIMD_CAST_AVX_1(ushort_v, int_v) { return _mm256_cvtepu16_epi32(AVX::lo128(x.data())); }\n#endif\n\n// 2: to int_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_2(double_v, int_v) { return AVX::concat(_mm256_cvttpd_epi32(x0.data()), _mm256_cvttpd_epi32(x1.data())); }\n#endif\n\n// 1: to uint_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_1(double_v, uint_v) { return AVX::zeroExtend(AVX::convert(x.data())); }\nVc_SIMD_CAST_AVX_1( float_v, uint_v) {\n return _mm256_blendv_epi8(\n _mm256_cvttps_epi32(x.data()),\n _mm256_add_epi32(\n _mm256_cvttps_epi32(_mm256_sub_ps(x.data(), AVX::set2power31_ps())),\n AVX::set2power31_epu32()),\n _mm256_castps_si256(AVX::cmpge_ps(x.data(), AVX::set2power31_ps())));\n}\nVc_SIMD_CAST_AVX_1( int_v, uint_v) { return x.data(); }\nVc_SIMD_CAST_AVX_1( short_v, uint_v) { return _mm256_cvtepi16_epi32(AVX::lo128(x.data())); }\nVc_SIMD_CAST_AVX_1(ushort_v, uint_v) { return _mm256_cvtepu16_epi32(AVX::lo128(x.data())); }\n#endif\n\n// 2: to uint_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_2(double_v, uint_v) { return AVX::concat(AVX::convert(x0.data()), AVX::convert(x1.data())); }\n#endif\n\n// 1: to short_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_1(double_v, short_v) { return AVX::zeroExtend(_mm_packs_epi32(_mm256_cvttpd_epi32(x.data()), _mm_setzero_si128())); }\nVc_SIMD_CAST_AVX_1( float_v, short_v) {\n const auto tmp = _mm256_cvttps_epi32(x.data());\n return AVX::zeroExtend(_mm_packs_epi32(AVX::lo128(tmp), AVX::hi128(tmp)));\n}\nVc_SIMD_CAST_AVX_1( int_v, short_v) { return AVX::zeroExtend(AVX::convert< int, short>(x.data())); }\nVc_SIMD_CAST_AVX_1( uint_v, short_v) { return AVX::zeroExtend(AVX::convert(x.data())); }\nVc_SIMD_CAST_AVX_1(ushort_v, short_v) { return x.data(); }\n#endif\n\n// 2: to short_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_2(double_v, short_v) {\n const auto tmp0 = _mm256_cvttpd_epi32(x0.data());\n const auto tmp1 = _mm256_cvttpd_epi32(x1.data());\n return AVX::zeroExtend(_mm_packs_epi32(tmp0, tmp1));\n}\nVc_SIMD_CAST_AVX_2( float_v, short_v) {\n using AVX2::short_v;\n using AVX2::int_v;\n return simd_cast(simd_cast(x0), simd_cast(x1));\n}\nVc_SIMD_CAST_AVX_2( int_v, short_v) {\n const auto shuf = _mm256_setr_epi8(\n 0, 1, 4, 5, 8, 9, 12, 13, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80,\n 0, 1, 4, 5, 8, 9, 12, 13, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80);\n auto a = _mm256_shuffle_epi8(x0.data(), shuf);\n auto b = _mm256_shuffle_epi8(x1.data(), shuf);\n return Mem::permute4x64(_mm256_unpacklo_epi64(a, b));\n}\nVc_SIMD_CAST_AVX_2( uint_v, short_v) {\n const auto shuf = _mm256_setr_epi8(\n 0, 1, 4, 5, 8, 9, 12, 13, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80,\n 0, 1, 4, 5, 8, 9, 12, 13, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80, -0x80);\n auto a = _mm256_shuffle_epi8(x0.data(), shuf);\n auto b = _mm256_shuffle_epi8(x1.data(), shuf);\n return Mem::permute4x64(_mm256_unpacklo_epi64(a, b));\n}\n#endif\n\n// 3: to short_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_3(double_v, short_v) {\n const auto tmp0 = _mm256_cvttpd_epi32(x0.data());\n const auto tmp1 = _mm256_cvttpd_epi32(x1.data());\n const auto tmp2 = _mm256_cvttpd_epi32(x2.data());\n return AVX::concat(_mm_packs_epi32(tmp0, tmp1), _mm_packs_epi32(tmp2, _mm_setzero_si128()));\n}\n#endif\n\n// 4: to short_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_4(double_v, short_v) {\n const auto tmp0 = _mm256_cvttpd_epi32(x0.data());\n const auto tmp1 = _mm256_cvttpd_epi32(x1.data());\n const auto tmp2 = _mm256_cvttpd_epi32(x2.data());\n const auto tmp3 = _mm256_cvttpd_epi32(x3.data());\n return AVX::concat(_mm_packs_epi32(tmp0, tmp1), _mm_packs_epi32(tmp2, tmp3));\n}\n#endif\n\n// 1: to ushort_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_1(double_v, ushort_v) {\n const auto tmp = _mm256_cvttpd_epi32(x.data());\n return AVX::zeroExtend(_mm_packus_epi32(tmp, _mm_setzero_si128()));\n}\nVc_SIMD_CAST_AVX_1( float_v, ushort_v) {\n const auto tmp = _mm256_cvttps_epi32(x.data());\n return AVX::zeroExtend(_mm_packus_epi32(AVX::lo128(tmp), AVX::hi128(tmp)));\n}\nVc_SIMD_CAST_AVX_1( int_v, ushort_v) { return AVX::zeroExtend(AVX::convert< int, ushort>(x.data())); }\nVc_SIMD_CAST_AVX_1( uint_v, ushort_v) { return AVX::zeroExtend(AVX::convert(x.data())); }\nVc_SIMD_CAST_AVX_1( short_v, ushort_v) { return x.data(); }\n#endif\n\n// 2: to ushort_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_2(double_v, ushort_v) {\n const auto tmp0 = _mm256_cvttpd_epi32(x0.data());\n const auto tmp1 = _mm256_cvttpd_epi32(x1.data());\n return AVX::zeroExtend(_mm_packus_epi32(tmp0, tmp1));\n}\nVc_SIMD_CAST_AVX_2( float_v, ushort_v) {\n using AVX2::ushort_v;\n using AVX2::int_v;\n return simd_cast(simd_cast(x0), simd_cast(x1));\n}\nVc_SIMD_CAST_AVX_2( int_v, ushort_v) {\n auto tmp0 = _mm256_unpacklo_epi16(x0.data(), x1.data());\n auto tmp1 = _mm256_unpackhi_epi16(x0.data(), x1.data());\n auto tmp2 = _mm256_unpacklo_epi16(tmp0, tmp1);\n auto tmp3 = _mm256_unpackhi_epi16(tmp0, tmp1);\n return Mem::permute4x64(_mm256_unpacklo_epi16(tmp2, tmp3));\n}\nVc_SIMD_CAST_AVX_2( uint_v, ushort_v) {\n auto tmp0 = _mm256_unpacklo_epi16(x0.data(), x1.data());\n auto tmp1 = _mm256_unpackhi_epi16(x0.data(), x1.data());\n auto tmp2 = _mm256_unpacklo_epi16(tmp0, tmp1);\n auto tmp3 = _mm256_unpackhi_epi16(tmp0, tmp1);\n return Mem::permute4x64(_mm256_unpacklo_epi16(tmp2, tmp3));\n}\n#endif\n\n// 3: to ushort_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_3(double_v, ushort_v) {\n const auto tmp0 = _mm256_cvttpd_epi32(x0.data());\n const auto tmp1 = _mm256_cvttpd_epi32(x1.data());\n const auto tmp2 = _mm256_cvttpd_epi32(x2.data());\n return AVX::concat(_mm_packus_epi32(tmp0, tmp1),\n _mm_packus_epi32(tmp2, _mm_setzero_si128()));\n}\n#endif\n\n// 4: to ushort_v {{{3\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_4(double_v, ushort_v) {\n const auto tmp0 = _mm256_cvttpd_epi32(x0.data());\n const auto tmp1 = _mm256_cvttpd_epi32(x1.data());\n const auto tmp2 = _mm256_cvttpd_epi32(x2.data());\n const auto tmp3 = _mm256_cvttpd_epi32(x3.data());\n return AVX::concat(_mm_packus_epi32(tmp0, tmp1), _mm_packus_epi32(tmp2, tmp3));\n}\n#endif\n\n// 1 SSE::Vector to 1 AVX2::Vector {{{2\nVc_SIMD_CAST_1(SSE::double_v, AVX2::double_v) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: float_v, AVX2::double_v) { return _mm256_cvtps_pd(x.data()); }\nVc_SIMD_CAST_1(SSE:: int_v, AVX2::double_v) { return _mm256_cvtepi32_pd(x.data()); }\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2::double_v) { using namespace AvxIntrinsics; return _mm256_add_pd(_mm256_cvtepi32_pd(_mm_sub_epi32(x.data(), _mm_setmin_epi32())), set1_pd(1u << 31)); }\nVc_SIMD_CAST_1(SSE:: short_v, AVX2::double_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2::double_v) { return simd_cast(simd_cast(x)); }\n\nVc_SIMD_CAST_1(SSE::double_v, AVX2:: float_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: float_v, AVX2:: float_v) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: int_v, AVX2:: float_v) { return AVX::zeroExtend(_mm_cvtepi32_ps(x.data())); }\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2:: float_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: short_v, AVX2:: float_v) { return AVX::convert< short, float>(x.data()); }\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2:: float_v) { return AVX::convert(x.data()); }\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(SSE::double_v, AVX2:: int_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE::double_v, AVX2:: uint_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE::double_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE::double_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x).data()); }\n\nVc_SIMD_CAST_1(SSE:: float_v, AVX2:: int_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: float_v, AVX2:: uint_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: float_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: float_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x).data()); }\n\nVc_SIMD_CAST_1(SSE:: int_v, AVX2:: int_v) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2:: int_v) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: short_v, AVX2:: int_v) { return AVX::convert< short, int>(x.data()); }\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2:: int_v) { return AVX::convert(x.data()); }\n\nVc_SIMD_CAST_1(SSE:: int_v, AVX2:: uint_v) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2:: uint_v) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: short_v, AVX2:: uint_v) { return AVX::convert< short, uint>(x.data()); }\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2:: uint_v) { return AVX::convert(x.data()); }\n\nVc_SIMD_CAST_1(SSE:: int_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: short_v, AVX2:: short_v) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2:: short_v) { return AVX::zeroExtend(x.data()); }\n\nVc_SIMD_CAST_1(SSE:: int_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: uint_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: short_v, AVX2::ushort_v) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE::ushort_v, AVX2::ushort_v) { return AVX::zeroExtend(x.data()); }\n#endif\n\n// 2 SSE::Vector to 1 AVX2::Vector {{{2\nVc_SIMD_CAST_2(SSE::double_v, AVX2::double_v) { return AVX::concat(x0.data(), x1.data()); }\n\nVc_SIMD_CAST_2(SSE::double_v, AVX2:: float_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\nVc_SIMD_CAST_2(SSE:: float_v, AVX2:: float_v) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: int_v, AVX2:: float_v) { return AVX::convert< int, float>(AVX::concat(x0.data(), x1.data())); }\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2:: float_v) { return AVX::convert(AVX::concat(x0.data(), x1.data())); }\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_2(SSE::double_v, AVX2:: int_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\nVc_SIMD_CAST_2(SSE::double_v, AVX2:: uint_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\nVc_SIMD_CAST_2(SSE::double_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\nVc_SIMD_CAST_2(SSE::double_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\n\nVc_SIMD_CAST_2(SSE:: float_v, AVX2:: int_v) { return simd_cast(simd_cast(x0, x1)); }\nVc_SIMD_CAST_2(SSE:: float_v, AVX2:: uint_v) { return simd_cast(simd_cast(x0, x1)); }\nVc_SIMD_CAST_2(SSE:: float_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\nVc_SIMD_CAST_2(SSE:: float_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\n\nVc_SIMD_CAST_2(SSE:: int_v, AVX2:: int_v) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2:: int_v) { return AVX::concat(x0.data(), x1.data()); }\n\nVc_SIMD_CAST_2(SSE:: int_v, AVX2:: uint_v) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2:: uint_v) { return AVX::concat(x0.data(), x1.data()); }\n\nVc_SIMD_CAST_2(SSE:: int_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\nVc_SIMD_CAST_2(SSE:: short_v, AVX2:: short_v) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE::ushort_v, AVX2:: short_v) { return AVX::concat(x0.data(), x1.data()); }\n\nVc_SIMD_CAST_2(SSE:: int_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\nVc_SIMD_CAST_2(SSE:: uint_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x0, x1).data()); }\nVc_SIMD_CAST_2(SSE:: short_v, AVX2::ushort_v) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE::ushort_v, AVX2::ushort_v) { return AVX::concat(x0.data(), x1.data()); }\n#endif\n// 3 SSE::Vector to 1 AVX2::Vector {{{2\nVc_SIMD_CAST_3(SSE::double_v, AVX2:: float_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2)); }\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_3(SSE::double_v, AVX2:: int_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2)); }\nVc_SIMD_CAST_3(SSE::double_v, AVX2:: uint_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2)); }\nVc_SIMD_CAST_3(SSE::double_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x0, x1, x2).data()); }\nVc_SIMD_CAST_3(SSE::double_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x0, x1, x2).data()); }\n\nVc_SIMD_CAST_3(SSE:: float_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2)); }\nVc_SIMD_CAST_3(SSE:: float_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2)); }\n\nVc_SIMD_CAST_3(SSE:: int_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2)); }\nVc_SIMD_CAST_3(SSE:: uint_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2)); }\n\nVc_SIMD_CAST_3(SSE:: int_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2)); }\nVc_SIMD_CAST_3(SSE:: uint_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2)); }\n#endif\n\n// 4 SSE::Vector to 1 AVX2::Vector {{{2\nVc_SIMD_CAST_4(SSE::double_v, AVX2:: float_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3)); }\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_4(SSE::double_v, AVX2:: int_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3)); }\nVc_SIMD_CAST_4(SSE::double_v, AVX2:: uint_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3)); }\nVc_SIMD_CAST_4(SSE::double_v, AVX2:: short_v) { return AVX::zeroExtend(simd_cast(x0, x1, x2, x3).data()); }\nVc_SIMD_CAST_4(SSE::double_v, AVX2::ushort_v) { return AVX::zeroExtend(simd_cast(x0, x1, x2, x3).data()); }\n\nVc_SIMD_CAST_4(SSE:: float_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3)); }\nVc_SIMD_CAST_4(SSE:: float_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3)); }\n\nVc_SIMD_CAST_4(SSE:: int_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3)); }\nVc_SIMD_CAST_4(SSE:: uint_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3)); }\n\nVc_SIMD_CAST_4(SSE:: int_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3)); }\nVc_SIMD_CAST_4(SSE:: uint_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3)); }\n#endif\n\n// 5 SSE::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_5(SSE::double_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3), simd_cast(x4)); }\nVc_SIMD_CAST_5(SSE::double_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3), simd_cast(x4)); }\n#endif\n\n// 6 SSE::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_6(SSE::double_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3), simd_cast(x4, x5)); }\nVc_SIMD_CAST_6(SSE::double_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3), simd_cast(x4, x5)); }\n#endif\n\n// 7 SSE::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_7(SSE::double_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3), simd_cast(x4, x5), simd_cast(x6)); }\nVc_SIMD_CAST_7(SSE::double_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3), simd_cast(x4, x5), simd_cast(x6)); }\n#endif\n\n// 8 SSE::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_8(SSE::double_v, AVX2:: short_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3), simd_cast(x4, x5), simd_cast(x6, x7)); }\nVc_SIMD_CAST_8(SSE::double_v, AVX2::ushort_v) { return simd_cast(simd_cast(x0, x1), simd_cast(x2, x3), simd_cast(x4, x5), simd_cast(x6, x7)); }\n#endif\n\n// 1 AVX2::Vector to 1 SSE::Vector {{{2\nVc_SIMD_CAST_1(AVX2::double_v, SSE::double_v) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2:: float_v, SSE:: float_v) { return AVX::lo128(x.data()); }\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(AVX2:: int_v, SSE:: int_v) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE:: uint_v) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2:: short_v, SSE:: short_v) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE::ushort_v) { return AVX::lo128(x.data()); }\n#endif\n\nVc_SIMD_CAST_1(AVX2::double_v, SSE:: float_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2::double_v, SSE:: int_v) { return AVX::convert(x.data()); }\nVc_SIMD_CAST_1(AVX2::double_v, SSE:: uint_v) { return AVX::convert(x.data()); }\nVc_SIMD_CAST_1(AVX2::double_v, SSE:: short_v) { return AVX::convert(x.data()); }\nVc_SIMD_CAST_1(AVX2::double_v, SSE::ushort_v) { return AVX::convert(x.data()); }\n\nVc_SIMD_CAST_1(AVX2:: float_v, SSE::double_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2:: float_v, SSE:: int_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2:: float_v, SSE:: uint_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2:: float_v, SSE:: short_v) { return AVX::convert(x.data()); }\nVc_SIMD_CAST_1(AVX2:: float_v, SSE::ushort_v) { return AVX::convert(x.data()); }\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(AVX2:: int_v, SSE::double_v) { return SSE::convert(AVX::lo128(x.data())); }\nVc_SIMD_CAST_1(AVX2:: int_v, SSE:: float_v) { return SSE::convert(AVX::lo128(x.data())); }\nVc_SIMD_CAST_1(AVX2:: int_v, SSE:: uint_v) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2:: int_v, SSE:: short_v) { return AVX::convert(x.data()); }\nVc_SIMD_CAST_1(AVX2:: int_v, SSE::ushort_v) { return AVX::convert(x.data()); }\n\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE::double_v) { return SSE::convert(AVX::lo128(x.data())); }\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE:: float_v) { return SSE::convert(AVX::lo128(x.data())); }\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE:: int_v) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE:: short_v) { return AVX::convert(x.data()); }\nVc_SIMD_CAST_1(AVX2:: uint_v, SSE::ushort_v) { return AVX::convert(x.data()); }\n\nVc_SIMD_CAST_1(AVX2:: short_v, SSE::double_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2:: short_v, SSE:: float_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2:: short_v, SSE:: int_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2:: short_v, SSE:: uint_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2:: short_v, SSE::ushort_v) { return simd_cast(simd_cast(x)); }\n\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE::double_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE:: float_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE:: int_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE:: uint_v) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_1(AVX2::ushort_v, SSE:: short_v) { return simd_cast(simd_cast(x)); }\n#endif\n\n// 2 AVX2::Vector to 1 SSE::Vector {{{2\nVc_SIMD_CAST_2(AVX2::double_v, SSE:: short_v) {\n const auto tmp0 = _mm256_cvttpd_epi32(x0.data());\n const auto tmp1 = _mm256_cvttpd_epi32(x1.data());\n return _mm_packs_epi32(tmp0, tmp1);\n}\nVc_SIMD_CAST_2(AVX2::double_v, SSE::ushort_v) {\n const auto tmp0 = _mm256_cvttpd_epi32(x0.data());\n const auto tmp1 = _mm256_cvttpd_epi32(x1.data());\n return _mm_packus_epi32(tmp0, tmp1);\n}\n\n// 1 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value>)\n{\n return AVX::zeroExtend(_mm_setr_pd(x.data(), 0.));\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value>)\n{\n return AVX::zeroExtend(_mm_setr_ps(x.data(), 0.f, 0.f, 0.f));\n}\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value>)\n{\n return _mm256_setr_epi32(x.data(), 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value>)\n{\n return _mm256_setr_epi32(uint(x.data()), 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\n#endif\n\n// 2 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value>)\n{\n return AVX::zeroExtend(_mm_setr_pd(x0.data(), x1.data()));\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value>)\n{\n return AVX::zeroExtend(_mm_setr_ps(x0.data(), x1.data(), 0.f, 0.f));\n}\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value>)\n{\n return _mm256_setr_epi32(x0.data(), x1.data(), 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value>)\n{\n return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\n#endif\n\n// 3 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value>)\n{\n return _mm256_setr_pd(x0.data(), x1.data(), x2.data(), 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value>)\n{\n return AVX::zeroExtend(_mm_setr_ps(x0.data(), x1.data(), x2.data(), 0));\n}\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value>)\n{\n return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value>)\n{\n return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()), 0, 0, 0,\n 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\n#endif\n\n// 4 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value>)\n{\n return _mm256_setr_pd(x0.data(), x1.data(), x2.data(), x3.data());\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value>)\n{\n return AVX::zeroExtend(_mm_setr_ps(x0.data(), x1.data(), x2.data(), x3.data()));\n}\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value>)\n{\n return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value>)\n{\n return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),\n uint(x3.data()), 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\n#endif\n\n// 5 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value>)\n{\n return _mm256_setr_ps(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0);\n}\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value>)\n{\n return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value>)\n{\n return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),\n uint(x3.data()), uint(x4.data()), 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\n#endif\n\n// 6 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value>)\n{\n return _mm256_setr_ps(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), 0, 0);\n}\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value>)\n{\n return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value>)\n{\n return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),\n uint(x3.data()), uint(x4.data()), uint(x5.data()), 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\n#endif\n\n// 7 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value>)\n{\n return _mm256_setr_ps(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), 0);\n}\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value>)\n{\n return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value>)\n{\n return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),\n uint(x3.data()), uint(x4.data()), uint(x5.data()),\n uint(x6.data()), 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), 0, 0, 0, 0, 0, 0, 0, 0, 0);\n}\n#endif\n\n// 8 Scalar::Vector to 1 AVX2::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value>)\n{\n return _mm256_setr_ps(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data());\n}\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value>)\n{\n return _mm256_setr_epi32(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data());\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value>)\n{\n return _mm256_setr_epi32(uint(x0.data()), uint(x1.data()), uint(x2.data()),\n uint(x3.data()), uint(x4.data()), uint(x5.data()),\n uint(x6.data()), uint(x7.data()));\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), 0, 0, 0, 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), 0, 0, 0, 0, 0, 0, 0, 0);\n}\n#endif\n\n// 9 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), 0, 0, 0, 0, 0, 0,\n 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), 0, 0, 0, 0, 0, 0,\n 0);\n}\n#endif\n\n// 10 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(), 0, 0,\n 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(), 0, 0,\n 0, 0, 0, 0);\n}\n#endif\n\n// 11 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), 0, 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), 0, 0, 0, 0, 0);\n}\n#endif\n\n// 12 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), 0, 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), 0, 0, 0, 0);\n}\n#endif\n\n// 13 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), x12.data(), 0, 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), x12.data(), 0, 0, 0);\n}\n#endif\n\n// 14 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), x12.data(), x13.data(), 0, 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), x12.data(), x13.data(), 0, 0);\n}\n#endif\n\n// 15 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13, Scalar::Vector x14,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), x12.data(), x13.data(), x14.data(),\n 0);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13, Scalar::Vector x14,\n enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), x12.data(), x13.data(), x14.data(),\n 0);\n}\n#endif\n\n// 16 Scalar::Vector to 1 AVX2::Vector {{{2\n#ifdef Vc_IMPL_AVX2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13, Scalar::Vector x14,\n Scalar::Vector x15, enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), x12.data(), x13.data(), x14.data(),\n x15.data());\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Vector x0, Scalar::Vector x1, Scalar::Vector x2,\n Scalar::Vector x3, Scalar::Vector x4, Scalar::Vector x5,\n Scalar::Vector x6, Scalar::Vector x7, Scalar::Vector x8,\n Scalar::Vector x9, Scalar::Vector x10, Scalar::Vector x11,\n Scalar::Vector x12, Scalar::Vector x13, Scalar::Vector x14,\n Scalar::Vector x15, enable_if::value>)\n{\n return _mm256_setr_epi16(x0.data(), x1.data(), x2.data(), x3.data(), x4.data(),\n x5.data(), x6.data(), x7.data(), x8.data(), x9.data(),\n x10.data(), x11.data(), x12.data(), x13.data(), x14.data(),\n x15.data());\n}\n#endif\n\n// 1 AVX2::Vector to 1 Scalar::Vector {{{2\ntemplate \nVc_INTRINSIC Vc_CONST To\nsimd_cast(AVX2::Vector x, enable_if::value>)\n{\n return static_cast(x[0]);\n}\n\n// Mask casts without offset {{{1\n// 1 AVX2::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\n simd_cast(const AVX2::Mask &k, enable_if::value>)\n{\n return {Detail::mask_cast::Size, Return::Size,\n typename Return::VectorTypeF>(k.dataI())};\n}\n\n// 2 AVX2::Mask to 1 AVX2::Mask {{{2\nVc_SIMD_CAST_AVX_2(double_m, float_m) { return AVX::concat(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI()))); }\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_2(double_m, int_m) { return Mem::permute4x64(_mm256_packs_epi32(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_AVX_2(double_m, uint_m) { return Mem::permute4x64(_mm256_packs_epi32(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_AVX_2(double_m, short_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI())))); }\nVc_SIMD_CAST_AVX_2(double_m, ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI())))); }\n\nVc_SIMD_CAST_AVX_2( float_m, short_m) { return Mem::permute4x64(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_AVX_2( float_m, ushort_m) { return Mem::permute4x64(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }\n\nVc_SIMD_CAST_AVX_2( int_m, short_m) { return Mem::permute4x64(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_AVX_2( int_m, ushort_m) { return Mem::permute4x64(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }\n\nVc_SIMD_CAST_AVX_2( uint_m, short_m) { return Mem::permute4x64(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_AVX_2( uint_m, ushort_m) { return Mem::permute4x64(_mm256_packs_epi16(x0.dataI(), x1.dataI())); }\n#endif\n\n// 4 AVX2::Mask to 1 AVX2::Mask {{{2\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_AVX_4(double_m, short_m)\n{\n using namespace AVX;\n const auto tmp = _mm256_packs_epi32(\n _mm256_packs_epi32(x0.dataI(), x1.dataI()) // a0 a1 b0 b1 a2 a3 b2 b3\n ,\n _mm256_packs_epi32(x2.dataI(), x3.dataI()) // c0 c1 d0 d1 c2 c3 d2 d3\n ); // a0 a1 b0 b1 c0 c1 d0 d1 a2 a3 b2 b3 c2 c3 d2 d3\n return concat(_mm_unpacklo_epi32(lo128(tmp), hi128(tmp)), // a0 a1 a2 a3 b0 b1 b2 b3\n _mm_unpackhi_epi32(lo128(tmp), hi128(tmp))); // c0 c1 c2 c3 d0 d1 d2 d3\n}\nVc_SIMD_CAST_AVX_4(double_m, ushort_m) { return simd_cast(x0, x1, x2, x3).data(); }\n#endif\n\n// 1 SSE::Mask to 1 AVX2::Mask {{{2\nVc_SIMD_CAST_1(SSE::double_m, AVX2::double_m) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE::double_m, AVX2:: float_m) { return AVX::zeroExtend(simd_cast(x).data()); }\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(SSE::double_m, AVX2:: int_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE::double_m, AVX2:: uint_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE::double_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE::double_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast(x).data()); }\n#endif\n\nVc_SIMD_CAST_1(SSE:: float_m, AVX2::double_m) { return AVX::concat(_mm_unpacklo_ps(x.dataF(), x.dataF()), _mm_unpackhi_ps(x.dataF(), x.dataF())); }\nVc_SIMD_CAST_1(SSE:: int_m, AVX2::double_m) { return AVX::concat(_mm_unpacklo_ps(x.dataF(), x.dataF()), _mm_unpackhi_ps(x.dataF(), x.dataF())); }\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2::double_m) { return AVX::concat(_mm_unpacklo_ps(x.dataF(), x.dataF()), _mm_unpackhi_ps(x.dataF(), x.dataF())); }\nVc_SIMD_CAST_1(SSE:: short_m, AVX2::double_m) { auto tmp = _mm_unpacklo_epi16(x.dataI(), x.dataI()); return AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)); }\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2::double_m) { auto tmp = _mm_unpacklo_epi16(x.dataI(), x.dataI()); return AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)); }\n\nVc_SIMD_CAST_1(SSE:: float_m, AVX2:: float_m) { return AVX::zeroExtend(x.dataF()); }\nVc_SIMD_CAST_1(SSE:: int_m, AVX2:: float_m) { return AVX::zeroExtend(x.dataF()); }\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2:: float_m) { return AVX::zeroExtend(x.dataF()); }\nVc_SIMD_CAST_1(SSE:: short_m, AVX2:: float_m) { return AVX::concat(_mm_unpacklo_epi16(x.dataI(), x.dataI()), _mm_unpackhi_epi16(x.dataI(), x.dataI())); }\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2:: float_m) { return AVX::concat(_mm_unpacklo_epi16(x.dataI(), x.dataI()), _mm_unpackhi_epi16(x.dataI(), x.dataI())); }\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(SSE:: float_m, AVX2:: int_m) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: float_m, AVX2:: uint_m) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: int_m, AVX2:: int_m) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: int_m, AVX2:: uint_m) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2:: int_m) { return AVX::zeroExtend(x.data()); }\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2:: uint_m) { return AVX::zeroExtend(x.data()); }\n\nVc_SIMD_CAST_1(SSE:: float_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: int_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: short_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2:: short_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: float_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: int_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: uint_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE:: short_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast(x).data()); }\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2::ushort_m) { return AVX::zeroExtend(simd_cast(x).data()); }\n\nVc_SIMD_CAST_1(SSE:: short_m, AVX2:: int_m) { const auto v = Mem::permute4x64(AVX::avx_cast<__m256i>(x.data())); return _mm256_unpacklo_epi16(v, v); }\nVc_SIMD_CAST_1(SSE:: short_m, AVX2:: uint_m) { const auto v = Mem::permute4x64(AVX::avx_cast<__m256i>(x.data())); return _mm256_unpacklo_epi16(v, v); }\n\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2:: int_m) { const auto v = Mem::permute4x64(AVX::avx_cast<__m256i>(x.data())); return _mm256_unpacklo_epi16(v, v); }\nVc_SIMD_CAST_1(SSE::ushort_m, AVX2:: uint_m) { const auto v = Mem::permute4x64(AVX::avx_cast<__m256i>(x.data())); return _mm256_unpacklo_epi16(v, v); }\n#endif\n\n// 2 SSE::Mask to 1 AVX2::Mask {{{2\nVc_SIMD_CAST_2(SSE::double_m, AVX2::double_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE::double_m, AVX2:: float_m) { return AVX::zeroExtend(_mm_packs_epi32(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_2(SSE:: float_m, AVX2:: float_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: int_m, AVX2:: float_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2:: float_m) { return AVX::concat(x0.data(), x1.data()); }\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_2(SSE::double_m, AVX2:: int_m) { return AVX::zeroExtend(_mm_packs_epi32(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_2(SSE::double_m, AVX2:: uint_m) { return AVX::zeroExtend(_mm_packs_epi32(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_2(SSE::double_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_setzero_si128())); }\nVc_SIMD_CAST_2(SSE::double_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_setzero_si128())); }\n\nVc_SIMD_CAST_2(SSE:: float_m, AVX2:: int_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: float_m, AVX2:: uint_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: float_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_2(SSE:: float_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }\n\nVc_SIMD_CAST_2(SSE:: int_m, AVX2:: int_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: int_m, AVX2:: uint_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: int_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_2(SSE:: int_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }\n\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2:: int_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2:: uint_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }\nVc_SIMD_CAST_2(SSE:: uint_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(x0.dataI(), x1.dataI())); }\n\nVc_SIMD_CAST_2(SSE:: short_m, AVX2:: short_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE:: short_m, AVX2::ushort_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE::ushort_m, AVX2:: short_m) { return AVX::concat(x0.data(), x1.data()); }\nVc_SIMD_CAST_2(SSE::ushort_m, AVX2::ushort_m) { return AVX::concat(x0.data(), x1.data()); }\n#endif\n\n// 4 SSE::Mask to 1 AVX2::Mask {{{2\nVc_SIMD_CAST_4(SSE::double_m, AVX2:: float_m) { return AVX::concat(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI())); }\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_4(SSE::double_m, AVX2:: int_m) { return AVX::concat(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI())); }\nVc_SIMD_CAST_4(SSE::double_m, AVX2:: uint_m) { return AVX::concat(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI())); }\nVc_SIMD_CAST_4(SSE::double_m, AVX2:: short_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI()))); }\nVc_SIMD_CAST_4(SSE::double_m, AVX2::ushort_m) { return AVX::zeroExtend(_mm_packs_epi16(_mm_packs_epi32(x0.dataI(), x1.dataI()), _mm_packs_epi32(x2.dataI(), x3.dataI()))); }\nVc_SIMD_CAST_4(SSE:: float_m, AVX2:: short_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }\nVc_SIMD_CAST_4(SSE:: float_m, AVX2::ushort_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }\nVc_SIMD_CAST_4(SSE:: int_m, AVX2:: short_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }\nVc_SIMD_CAST_4(SSE:: int_m, AVX2::ushort_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }\nVc_SIMD_CAST_4(SSE:: uint_m, AVX2:: short_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }\nVc_SIMD_CAST_4(SSE:: uint_m, AVX2::ushort_m) { return AVX::concat(_mm_packs_epi16(x0.dataI(), x1.dataI()), _mm_packs_epi16(x2.dataI(), x3.dataI())); }\n#endif\n\n// 1 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Mask k, enable_if::value>)\n{\n Return r{false};\n r[0] = k.data();\n return r;\n}\n\n// 2 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Mask k0, Scalar::Mask k1,\n enable_if::value>)\n{\n Return r{false};\n r[0] = k0.data();\n r[1] = k1.data();\n return r;\n}\n\n// 4 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Mask k0, Scalar::Mask k1, Scalar::Mask k2, Scalar::Mask k3,\n enable_if<(AVX2::is_mask::value && Return::Size >= 4)>)\n{\n Return r{false};\n r[0] = k0.data();\n r[1] = k1.data();\n r[2] = k2.data();\n r[3] = k3.data();\n return r;\n}\n\n// 8 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Mask k0, Scalar::Mask k1, Scalar::Mask k2, Scalar::Mask k3,\n Scalar::Mask k4, Scalar::Mask k5, Scalar::Mask k6, Scalar::Mask k7,\n enable_if<(AVX2::is_mask::value && Return::Size >= 8)>)\n{\n Return r{false};\n r[0] = k0.data();\n r[1] = k1.data();\n r[2] = k2.data();\n r[3] = k3.data();\n r[4] = k4.data();\n r[5] = k5.data();\n r[6] = k6.data();\n r[7] = k7.data();\n return r;\n}\n\n// 16 Scalar::Mask to 1 AVX2::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(Scalar::Mask k0, Scalar::Mask k1, Scalar::Mask k2, Scalar::Mask k3,\n Scalar::Mask k4, Scalar::Mask k5, Scalar::Mask k6, Scalar::Mask k7,\n Scalar::Mask k8, Scalar::Mask k9, Scalar::Mask k10,\n Scalar::Mask k11, Scalar::Mask k12, Scalar::Mask k13,\n Scalar::Mask k14, Scalar::Mask k15,\n enable_if<(AVX2::is_mask::value && Return::Size >= 16)>)\n{\n Return r{false};\n r[0] = k0.data();\n r[1] = k1.data();\n r[2] = k2.data();\n r[3] = k3.data();\n r[4] = k4.data();\n r[5] = k5.data();\n r[6] = k6.data();\n r[7] = k7.data();\n r[8] = k8.data();\n r[9] = k9.data();\n r[10] = k10.data();\n r[11] = k11.data();\n r[12] = k12.data();\n r[13] = k13.data();\n r[14] = k14.data();\n r[15] = k15.data();\n return r;\n}\n\n// 1 AVX2::Mask to 1 SSE::Mask {{{2\nVc_SIMD_CAST_1(AVX2::double_m, SSE::double_m) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2::double_m, SSE:: float_m) { return _mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }\nVc_SIMD_CAST_1(AVX2::double_m, SSE:: int_m) { return _mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }\nVc_SIMD_CAST_1(AVX2::double_m, SSE:: uint_m) { return _mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }\nVc_SIMD_CAST_1(AVX2::double_m, SSE:: short_m) { return _mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())), _mm_setzero_si128()); }\nVc_SIMD_CAST_1(AVX2::double_m, SSE::ushort_m) { return _mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())), _mm_setzero_si128()); }\n\nVc_SIMD_CAST_1(AVX2:: float_m, SSE::double_m) { return _mm_unpacklo_ps(AVX::lo128(x.data()), AVX::lo128(x.data())); }\nVc_SIMD_CAST_1(AVX2:: float_m, SSE:: float_m) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2:: float_m, SSE:: int_m) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2:: float_m, SSE:: uint_m) { return AVX::lo128(x.data()); }\nVc_SIMD_CAST_1(AVX2:: float_m, SSE:: short_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }\nVc_SIMD_CAST_1(AVX2:: float_m, SSE::ushort_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }\n\n#ifdef Vc_IMPL_AVX2\nVc_SIMD_CAST_1(AVX2:: int_m, SSE::double_m) { return _mm_unpacklo_epi32(AVX::lo128(x.dataI()), AVX::lo128(x.dataI())); }\nVc_SIMD_CAST_1(AVX2:: int_m, SSE:: float_m) { return AVX::lo128(x.dataI()); }\nVc_SIMD_CAST_1(AVX2:: int_m, SSE:: int_m) { return AVX::lo128(x.dataI()); }\nVc_SIMD_CAST_1(AVX2:: int_m, SSE:: uint_m) { return AVX::lo128(x.dataI()); }\nVc_SIMD_CAST_1(AVX2:: int_m, SSE:: short_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }\nVc_SIMD_CAST_1(AVX2:: int_m, SSE::ushort_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }\n\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE::double_m) { return _mm_unpacklo_epi32(AVX::lo128(x.dataI()), AVX::lo128(x.dataI())); }\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE:: float_m) { return AVX::lo128(x.dataI()); }\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE:: int_m) { return AVX::lo128(x.dataI()); }\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE:: uint_m) { return AVX::lo128(x.dataI()); }\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE:: short_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }\nVc_SIMD_CAST_1(AVX2:: uint_m, SSE::ushort_m) { return _mm_packs_epi16(AVX::lo128(x.dataI()), AVX::hi128(x.dataI())); }\n\nVc_SIMD_CAST_1(AVX2:: short_m, SSE::double_m) { return simd_cast(SSE::short_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2:: short_m, SSE:: float_m) { return simd_cast(SSE::short_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2:: short_m, SSE:: int_m) { return simd_cast(SSE::short_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2:: short_m, SSE:: uint_m) { return simd_cast(SSE::short_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2:: short_m, SSE:: short_m) { return simd_cast(SSE::short_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2:: short_m, SSE::ushort_m) { return simd_cast(SSE::short_m(AVX::lo128(x.data()))); }\n\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE::double_m) { return simd_cast(SSE::ushort_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE:: float_m) { return simd_cast(SSE::ushort_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE:: int_m) { return simd_cast(SSE::ushort_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE:: uint_m) { return simd_cast(SSE::ushort_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE:: short_m) { return simd_cast(SSE::ushort_m(AVX::lo128(x.data()))); }\nVc_SIMD_CAST_1(AVX2::ushort_m, SSE::ushort_m) { return simd_cast(SSE::ushort_m(AVX::lo128(x.data()))); }\n#endif\n\n// 2 AVX2::Mask to 1 SSE::Mask {{{2\nVc_SIMD_CAST_2(AVX2::double_m, SSE:: short_m) { return _mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI()))); }\nVc_SIMD_CAST_2(AVX2::double_m, SSE::ushort_m) { return _mm_packs_epi16(_mm_packs_epi32(AVX::lo128(x0.dataI()), AVX::hi128(x0.dataI())), _mm_packs_epi32(AVX::lo128(x1.dataI()), AVX::hi128(x1.dataI()))); }\n\n// 1 AVX2::Mask to 1 Scalar::Mask {{{2\ntemplate \nVc_INTRINSIC Vc_CONST To\nsimd_cast(AVX2::Mask x, enable_if::value>)\n{\n return static_cast(x[0]);\n}\n\n// offset == 0 | convert from AVX2::Mask/Vector {{{1\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<\n (offset == 0 &&\n ((AVX2::is_vector::value && !Scalar::is_vector::value &&\n Traits::is_simd_vector::value && !Traits::isSimdArray::value) ||\n (AVX2::is_mask::value && !Scalar::is_mask::value &&\n Traits::is_simd_mask::value &&\n !Traits::isSimdMaskArray::value))),\n Return>\nsimd_cast(const From &x)\n{\n return simd_cast(x);\n}\n\n// offset == 0 | convert from SSE::Mask/Vector to AVX2::Mask/Vector {{{1\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(const From &x,\n enable_if::value &&\n AVX2::is_vector::value) ||\n (SSE::is_mask::value &&\n AVX2::is_mask::value))>)\n{\n return simd_cast(x);\n}\n\n// Vector casts with offset {{{1\n// AVX2 to AVX2 {{{2\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(AVX2::is_vector::value && offset != 0),\n Return>\n simd_cast(AVX2::Vector x)\n{\n // TODO: there certainly is potential for leaving out the shift/permute\n // instruction at the cost of a lot more specializations\n using V = AVX2::Vector;\n constexpr int shift = sizeof(T) * offset * Return::Size;\n static_assert(shift > 0 && shift < sizeof(x), \"\");\n if (shift < 16) {\n return simd_cast(V{AVX::avx_cast(\n _mm_srli_si128(AVX::avx_cast<__m128i>(AVX::lo128(x.data())), shift))});\n } else if (shift == 16) {\n return simd_cast(V{Mem::permute128(x.data())});\n } else {\n#ifdef Vc_MSVC\n#pragma warning(push)\n#pragma warning(disable : 4556) // value of intrinsic immediate argument '-8' is out of\n // range '0 - 255'\n#endif\n return simd_cast(V{AVX::avx_cast(\n _mm_srli_si128(AVX::avx_cast<__m128i>(AVX::hi128(x.data())), shift - 16))});\n#ifdef Vc_MSVC\n#pragma warning(pop)\n#endif\n }\n}\n// AVX2 to SSE (Vector) {{{2\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_vector::value &&\n sizeof(AVX2::Vector) == 32),\n Return>\n simd_cast(AVX2::Vector x)\n{\n using V = AVX2::Vector;\n constexpr int shift = sizeof(V) / V::Size * offset * Return::Size;\n static_assert(shift > 0, \"\");\n static_assert(shift < sizeof(V), \"\");\n using SseVector = SSE::Vector;\n if (shift == 16) {\n return simd_cast(SseVector{AVX::hi128(x.data())});\n }\n using Intrin = typename SseVector::VectorType;\n return simd_cast(SseVector{AVX::avx_cast(\n _mm_alignr_epi8(AVX::avx_cast<__m128i>(AVX::hi128(x.data())),\n AVX::avx_cast<__m128i>(AVX::lo128(x.data())), shift))});\n}\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_vector::value &&\n sizeof(AVX2::Vector) == 16),\n Return>\n simd_cast(AVX2::Vector x)\n{\n using V = AVX2::Vector;\n constexpr int shift = sizeof(V) / V::Size * offset * Return::Size;\n static_assert(shift > 0, \"\");\n static_assert(shift < sizeof(V), \"\");\n using SseVector = SSE::Vector;\n return simd_cast(SseVector{_mm_srli_si128(x.data(), shift)});\n}\n// SSE to AVX2 {{{2\nVc_SIMD_CAST_OFFSET(SSE:: short_v, AVX2::double_v, 1) { return simd_cast(simd_cast(x)); }\nVc_SIMD_CAST_OFFSET(SSE::ushort_v, AVX2::double_v, 1) { return simd_cast(simd_cast(x)); }\n\n// Mask casts with offset {{{1\n// 1 AVX2::Mask to N AVX2::Mask {{{2\n// float_v and (u)int_v have size 8, double_v has size 4, and (u)short_v have size 16. Consequently,\n// offset can 0, 1, 2, or 3.\n// - offset == 0 is already done.\n// - offset == 1 can be 16 -> 8, 16 -> 4, 8 -> 4, and 16 -> 4\n// - offset == 2 && offset == 3 can only be 16 -> 4\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(const AVX2::Mask &k,\n enable_if<(AVX2::is_mask::value && offset == 1 &&\n AVX2::Mask::Size == Return::Size * 2)> = nullarg)\n{\n const auto tmp = AVX::hi128(k.dataI());\n return AVX::concat(_mm_unpacklo_epi8(tmp, tmp), _mm_unpackhi_epi8(tmp, tmp));\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(const AVX2::Mask &k,\n enable_if<(AVX2::is_mask::value && offset == 1 &&\n AVX2::Mask::Size == Return::Size * 4)> = nullarg)\n{\n auto tmp = AVX::lo128(k.dataI());\n tmp = _mm_unpackhi_epi8(tmp, tmp);\n return AVX::concat(_mm_unpacklo_epi16(tmp, tmp), _mm_unpackhi_epi16(tmp, tmp));\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(const AVX2::Mask &k,\n enable_if<(AVX2::is_mask::value && offset == 2 &&\n AVX2::Mask::Size == Return::Size * 4)> = nullarg)\n{\n auto tmp = AVX::hi128(k.dataI());\n tmp = _mm_unpacklo_epi8(tmp, tmp);\n return AVX::concat(_mm_unpacklo_epi16(tmp, tmp), _mm_unpackhi_epi16(tmp, tmp));\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return\nsimd_cast(const AVX2::Mask &k,\n enable_if<(AVX2::is_mask::value && offset == 3 &&\n AVX2::Mask::Size == Return::Size * 4)> = nullarg)\n{\n auto tmp = AVX::hi128(k.dataI());\n tmp = _mm_unpackhi_epi8(tmp, tmp);\n return AVX::concat(_mm_unpacklo_epi16(tmp, tmp), _mm_unpackhi_epi16(tmp, tmp));\n}\n\n// 1 SSE::Mask to N AVX2::Mask {{{2\nVc_SIMD_CAST_OFFSET(SSE:: short_m, AVX2::double_m, 1) { auto tmp = _mm_unpackhi_epi16(x.dataI(), x.dataI()); return AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)); }\nVc_SIMD_CAST_OFFSET(SSE::ushort_m, AVX2::double_m, 1) { auto tmp = _mm_unpackhi_epi16(x.dataI(), x.dataI()); return AVX::concat(_mm_unpacklo_epi32(tmp, tmp), _mm_unpackhi_epi32(tmp, tmp)); }\n\n// AVX2 to SSE (Mask) {{{2\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_mask::value &&\n sizeof(AVX2::Mask) == 32),\n Return>\n simd_cast(AVX2::Mask x)\n{\n using M = AVX2::Mask;\n constexpr int shift = sizeof(M) / M::Size * offset * Return::Size;\n static_assert(shift > 0, \"\");\n static_assert(shift < sizeof(M), \"\");\n using SseVector = SSE::Mask>;\n if (shift == 16) {\n return simd_cast(SseVector{AVX::hi128(x.data())});\n }\n using Intrin = typename SseVector::VectorType;\n return simd_cast(SseVector{AVX::avx_cast(\n _mm_alignr_epi8(AVX::hi128(x.dataI()), AVX::lo128(x.dataI()), shift))});\n}\n\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(offset != 0 && SSE::is_mask::value &&\n sizeof(AVX2::Mask) == 16),\n Return>\n simd_cast(AVX2::Mask x)\n{\n return simd_cast(simd_cast>(x));\n}\n\n// undef Vc_SIMD_CAST_AVX_[1234] & Vc_SIMD_CAST_[12345678] {{{1\n#undef Vc_SIMD_CAST_AVX_1\n#undef Vc_SIMD_CAST_AVX_2\n#undef Vc_SIMD_CAST_AVX_3\n#undef Vc_SIMD_CAST_AVX_4\n\n#undef Vc_SIMD_CAST_1\n#undef Vc_SIMD_CAST_2\n#undef Vc_SIMD_CAST_3\n#undef Vc_SIMD_CAST_4\n#undef Vc_SIMD_CAST_5\n#undef Vc_SIMD_CAST_6\n#undef Vc_SIMD_CAST_7\n#undef Vc_SIMD_CAST_8\n\n#undef Vc_SIMD_CAST_OFFSET\n// }}}1\n\n} // namespace Vc\n\n#endif // VC_AVX_SIMD_CAST_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/avx/simd_cast_caller.tcc", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef Vc_AVX_SIMD_CAST_CALLER_TCC_\n#define Vc_AVX_SIMD_CAST_CALLER_TCC_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n#if Vc_IS_VERSION_1\ntemplate \ntemplate \nVc_INTRINSIC Vector::Vector(U &&x)\n : d(simd_cast(std::forward(x)).data())\n{\n}\n\ntemplate \ntemplate \nVc_INTRINSIC Mask::Mask(U &&rhs,\n Common::enable_if_mask_converts_explicitly)\n : Mask(simd_cast(std::forward(rhs)))\n{\n}\n#endif // Vc_IS_VERSION_1\n}\n\n#endif // Vc_AVX_SIMD_CAST_CALLER_TCC_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/avx/types.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_TYPES_H_\n#define VC_AVX_TYPES_H_\n\n#include \"../sse/types.h\"\n#include \"../traits/type_traits.h\"\n#include \"macros.h\"\n\n#ifdef Vc_DEFAULT_IMPL_AVX2\n#define Vc_DOUBLE_V_SIZE 4\n#define Vc_FLOAT_V_SIZE 8\n#define Vc_INT_V_SIZE 8\n#define Vc_UINT_V_SIZE 8\n#define Vc_SHORT_V_SIZE 16\n#define Vc_USHORT_V_SIZE 16\n#elif defined Vc_DEFAULT_IMPL_AVX\n#define Vc_DOUBLE_V_SIZE 4\n#define Vc_FLOAT_V_SIZE 8\n#define Vc_INT_V_SIZE 4\n#define Vc_UINT_V_SIZE 4\n#define Vc_SHORT_V_SIZE 8\n#define Vc_USHORT_V_SIZE 8\n#endif\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AVX\n{\ntemplate using Vector = Vc::Vector>;\ntypedef Vector double_v;\ntypedef Vector float_v;\ntypedef Vector int_v;\ntypedef Vector uint_v;\ntypedef Vector short_v;\ntypedef Vector ushort_v;\n\ntemplate using Mask = Vc::Mask>;\ntypedef Mask double_m;\ntypedef Mask float_m;\ntypedef Mask int_m;\ntypedef Mask uint_m;\ntypedef Mask short_m;\ntypedef Mask ushort_m;\n\ntemplate struct Const;\n\ntemplate struct is_vector : public std::false_type {};\ntemplate struct is_vector> : public std::true_type {};\ntemplate struct is_mask : public std::false_type {};\ntemplate struct is_mask> : public std::true_type {};\n} // namespace AVX\n\nnamespace AVX2\n{\ntemplate using Vector = Vc::Vector;\nusing double_v = Vector;\nusing float_v = Vector< float>;\nusing int_v = Vector< int>;\nusing uint_v = Vector< uint>;\nusing short_v = Vector< short>;\nusing ushort_v = Vector;\n\ntemplate using Mask = Vc::Mask;\nusing double_m = Mask;\nusing float_m = Mask< float>;\nusing llong_m = Mask< llong>;\nusing ullong_m = Mask;\nusing long_m = Mask< long>;\nusing ulong_m = Mask< ulong>;\nusing int_m = Mask< int>;\nusing uint_m = Mask< uint>;\nusing short_m = Mask< short>;\nusing ushort_m = Mask;\nusing schar_m = Mask< schar>;\nusing uchar_m = Mask< uchar>;\n\ntemplate struct is_vector : public std::false_type {};\ntemplate struct is_vector> : public std::true_type {};\ntemplate struct is_mask : public std::false_type {};\ntemplate struct is_mask> : public std::true_type {};\n} // namespace AVX2\n\nnamespace Traits\n{\ntemplate struct\nis_simd_vector_internal>\n : public is_valid_vector_argument {};\n\ntemplate struct is_simd_mask_internal>\n : public std::true_type {};\n} // namespace Traits\n} // namespace Vc\n\n#endif // VC_AVX_TYPES_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/vector.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_VECTOR_H_\n#define VC_AVX_VECTOR_H_\n\n#include \"intrinsics.h\"\n#include \"casts.h\"\n#include \"../sse/vector.h\"\n#include \"shuffle.h\"\n#include \"vectorhelper.h\"\n#include \"mask.h\"\n#include \n#include \n#include \"../common/aliasingentryhelper.h\"\n#include \"../common/memoryfwd.h\"\n#include \"../common/where.h\"\n#include \"macros.h\"\n\n#ifdef isfinite\n#undef isfinite\n#endif\n#ifdef isnan\n#undef isnan\n#endif\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Detail\n{\ntemplate struct VectorTraits\n{\n using mask_type = Vc::Mask;\n using vector_type = Vc::Vector;\n using writemasked_vector_type = Common::WriteMaskedVector;\n using intrinsic_type = typename AVX::VectorTypeHelper::Type;\n};\n} // namespace Detail\n\n#define Vc_CURRENT_CLASS_NAME Vector\ntemplate class Vector\n{\npublic:\n using abi = VectorAbi::Avx;\n\nprivate:\n using traits_type = Detail::VectorTraits;\n static_assert(\n std::is_arithmetic::value,\n \"Vector only accepts arithmetic builtin types as template parameter T.\");\n\n using WriteMaskedVector = typename traits_type::writemasked_vector_type;\n\npublic:\n using VectorType = typename traits_type::intrinsic_type;\n using vector_type = VectorType;\n\n using mask_type = typename traits_type::mask_type;\n using Mask = mask_type;\n using MaskType = mask_type;\n using MaskArg Vc_DEPRECATED_ALIAS(\"Use MaskArgument instead.\") = typename Mask::AsArg;\n using MaskArgument = typename Mask::AsArg;\n using reference = Detail::ElementReference;\n\n Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(VectorType));\n\n using EntryType = T;\n using value_type = EntryType;\n typedef EntryType VectorEntryType;\n static constexpr size_t Size = sizeof(VectorType) / sizeof(EntryType);\n static constexpr size_t MemoryAlignment = alignof(VectorType);\n using IndexType = fixed_size_simd;\n using index_type = IndexType;\n typedef Vector AsArg;\n typedef VectorType VectorTypeArg;\n\n protected:\n template using V = Vector;\n\n // helper that specializes on VectorType\n typedef AVX::VectorHelper HV;\n\n // helper that specializes on T\n typedef AVX::VectorHelper HT;\n\n // cast any m256/m128 to VectorType\n template static Vc_INTRINSIC VectorType _cast(V v)\n {\n return AVX::avx_cast(v);\n }\n\n typedef Common::VectorMemoryUnion StorageType;\n StorageType d;\n\n using WidthT = Common::WidthT;\n // ICC can't compile this:\n // static constexpr WidthT Width = WidthT();\n\n public:\n#include \"../common/generalinterface.h\"\n\n static Vc_ALWAYS_INLINE_L Vector Random() Vc_ALWAYS_INLINE_R;\n\n ///////////////////////////////////////////////////////////////////////////////////////////\n // internal: required to enable returning objects of VectorType\n Vc_ALWAYS_INLINE Vector(VectorTypeArg x) : d(x) {}\n\n // implict conversion from compatible Vector\n template \n Vc_INTRINSIC Vector(\n V x, typename std::enable_if::value,\n void *>::type = nullptr)\n : d(AVX::convert(x.data()))\n {\n }\n\n#if Vc_IS_VERSION_1\n // static_cast from the remaining Vector\n template \n Vc_DEPRECATED(\"use simd_cast instead of explicit type casting to convert between \"\n \"vector types\") Vc_INTRINSIC explicit Vector(\n V x,\n typename std::enable_if::value,\n void *>::type = nullptr)\n : d(Detail::zeroExtendIfNeeded(AVX::convert(x.data())))\n {\n }\n\n // static_cast from other types, implemented via the non-member simd_cast function in\n // simd_cast_caller.tcc\n template ::value &&\n !std::is_same>::value>>\n Vc_DEPRECATED(\"use simd_cast instead of explicit type casting to convert between \"\n \"vector types\") Vc_INTRINSIC_L\n explicit Vector(U &&x) Vc_INTRINSIC_R;\n#endif\n\n Vc_INTRINSIC explicit Vector(reference a) : Vector(static_cast(a)) {}\n\n ///////////////////////////////////////////////////////////////////////////////////////////\n // broadcast\n Vc_INTRINSIC Vector(EntryType a) : d(Detail::avx_broadcast(a)) {}\n template \n Vc_INTRINSIC Vector(U a,\n typename std::enable_if::value &&\n !std::is_same::value,\n void *>::type = nullptr)\n : Vector(static_cast(a))\n {\n }\n\n //template\n explicit Vector(std::initializer_list)\n {\n static_assert(std::is_same::value,\n \"A SIMD vector object cannot be initialized from an initializer list \"\n \"because the number of entries in the vector is target-dependent.\");\n }\n\n#include \"../common/loadinterface.h\"\n#include \"../common/storeinterface.h\"\n\n ///////////////////////////////////////////////////////////////////////////////////////////\n // zeroing\n Vc_INTRINSIC_L void setZero() Vc_INTRINSIC_R;\n Vc_INTRINSIC_L void setZero(const Mask &k) Vc_INTRINSIC_R;\n Vc_INTRINSIC_L void setZeroInverted(const Mask &k) Vc_INTRINSIC_R;\n\n Vc_INTRINSIC_L void setQnan() Vc_INTRINSIC_R;\n Vc_INTRINSIC_L void setQnan(MaskArgument k) Vc_INTRINSIC_R;\n\n#include \"../common/gatherinterface.h\"\n#include \"../common/scatterinterface.h\"\n#if defined Vc_IMPL_AVX2 && !defined Vc_MSVC\n // skip this code for MSVC because it fails to do overload resolution correctly\n\n ////////////////////////////////////////////////////////////////////////////////\n // non-converting pd, ps, and epi32 gathers\n template ::size(),\n class = enable_if<(Vector::size() >= size() && sizeof(T) >= 4)>>\n Vc_INTRINSIC void gatherImplementation(\n const Common::GatherArguments, Scale> &args)\n {\n d.v() = AVX::gather(\n args.address,\n simd_cast>(args.indexes)\n .data());\n }\n\n // masked overload\n template ::size(),\n class = enable_if<(Vector::size() >= size() && sizeof(T) >= 4)>>\n Vc_INTRINSIC void gatherImplementation(\n const Common::GatherArguments, Scale> &args, MaskArgument k)\n {\n d.v() = AVX::gather(\n d.v(), k.data(), args.address,\n simd_cast>(args.indexes)\n .data());\n }\n\n ////////////////////////////////////////////////////////////////////////////////\n // converting (from 8-bit and 16-bit integers only) epi16 gather emulation via\n // epi32 gathers\n template <\n class MT, class U, class A, int Scale,\n class = enable_if<(sizeof(T) == 2 && std::is_integral::value &&\n (sizeof(MT) <= 2) && Vector::size() >= size())>>\n Vc_INTRINSIC void gatherImplementation(\n const Common::GatherArguments, Scale> &args)\n {\n using AVX2::int_v;\n const auto idx0 = simd_cast(args.indexes).data();\n const auto idx1 = simd_cast(args.indexes).data();\n *this = simd_cast(int_v(AVX::gather(\n aliasing_cast(args.address), idx0)),\n int_v(AVX::gather(\n aliasing_cast(args.address), idx1)));\n if (sizeof(MT) == 1) {\n if (std::is_signed::value) {\n using Signed = AVX2::Vector::type>;\n *this = (simd_cast(*this) << 8) >> 8; // sign extend\n } else {\n *this &= 0xff;\n }\n }\n }\n\n // masked overload\n template <\n class MT, class U, class A, int Scale,\n class = enable_if<(sizeof(T) == 2 && std::is_integral::value &&\n (sizeof(MT) <= 2) && Vector::size() >= size())>>\n Vc_INTRINSIC void gatherImplementation(\n const Common::GatherArguments, Scale> &args, MaskArgument k)\n {\n using AVX2::int_v;\n const auto idx0 = simd_cast(args.indexes).data();\n const auto idx1 = simd_cast(args.indexes).data();\n const auto k0 = simd_cast(k).data();\n const auto k1 = simd_cast(k).data();\n auto v = simd_cast(\n int_v(AVX::gather(\n _mm256_setzero_si256(), k0, aliasing_cast(args.address), idx0)),\n int_v(AVX::gather(\n _mm256_setzero_si256(), k1, aliasing_cast(args.address), idx1)));\n if (sizeof(MT) == 1) {\n if (std::is_signed::value) {\n using Signed = AVX2::Vector::type>;\n v = (simd_cast(v) << 8) >> 8; // sign extend\n } else {\n v &= 0xff;\n }\n }\n assign(v, k);\n }\n\n ////////////////////////////////////////////////////////////////////////////////\n // all remaining converting gathers\n template \n Vc_INTRINSIC enable_if<((sizeof(T) != 2 || sizeof(MT) > 2) &&\n Traits::is_valid_vector_argument::value &&\n !std::is_same::value &&\n Vector::size() >= size()),\n void>\n gatherImplementation(const Common::GatherArguments, Scale> &args)\n {\n *this = simd_cast(fixed_size_simd(args));\n }\n\n // masked overload\n template \n Vc_INTRINSIC enable_if<((sizeof(T) != 2 || sizeof(MT) > 2) &&\n Traits::is_valid_vector_argument::value &&\n !std::is_same::value &&\n Vector::size() >= size()),\n void>\n gatherImplementation(const Common::GatherArguments, Scale> &args,\n MaskArgument k)\n {\n assign(simd_cast(fixed_size_simd(args, k)), k);\n }\n#endif // Vc_IMPL_AVX2 && !MSVC\n\n ///////////////////////////////////////////////////////////////////////////////////////////\n //prefix\n Vc_ALWAYS_INLINE Vector &operator++() { data() = Detail::add(data(), Detail::one(T()), T()); return *this; }\n Vc_ALWAYS_INLINE Vector &operator--() { data() = Detail::sub(data(), Detail::one(T()), T()); return *this; }\n //postfix\n Vc_ALWAYS_INLINE Vector operator++(int) { const Vector r = *this; data() = Detail::add(data(), Detail::one(T()), T()); return r; }\n Vc_ALWAYS_INLINE Vector operator--(int) { const Vector r = *this; data() = Detail::sub(data(), Detail::one(T()), T()); return r; }\n\n private:\n friend reference;\n Vc_INTRINSIC static value_type get(const Vector &o, int i) noexcept\n {\n return o.d.m(i);\n }\n template \n Vc_INTRINSIC static void set(Vector &o, int i, U &&v) noexcept(\n noexcept(std::declval() = v))\n {\n return o.d.set(i, v);\n }\n\n public:\n /**\n * \\note the returned object models the concept of a reference and\n * as such it can exist longer than the data it is referencing.\n * \\note to avoid lifetime issues, we strongly advice not to store\n * any reference objects.\n */\n Vc_ALWAYS_INLINE reference operator[](size_t index) noexcept\n {\n static_assert(noexcept(reference{std::declval(), int()}), \"\");\n return {*this, int(index)};\n }\n Vc_ALWAYS_INLINE value_type operator[](size_t index) const noexcept\n {\n return d.m(index);\n }\n\n Vc_INTRINSIC_L Vc_PURE_L Vector operator[](Permutation::ReversedTag) const Vc_INTRINSIC_R Vc_PURE_R;\n Vc_INTRINSIC_L Vc_PURE_L Vector operator[](const IndexType &perm) const Vc_INTRINSIC_R Vc_PURE_R;\n\n Vc_INTRINSIC Vc_PURE Mask operator!() const\n {\n return *this == Zero();\n }\n Vc_ALWAYS_INLINE Vector operator~() const\n {\n#ifndef Vc_ENABLE_FLOAT_BIT_OPERATORS\n static_assert(std::is_integral::value,\n \"bit-complement can only be used with Vectors of integral type\");\n#endif\n return Detail::andnot_(data(), Detail::allone());\n }\n Vc_ALWAYS_INLINE_L Vc_PURE_L Vector operator-() const Vc_ALWAYS_INLINE_R Vc_PURE_R;\n Vc_INTRINSIC Vc_PURE Vector operator+() const { return *this; }\n\n // shifts\n#define Vc_OP_VEC(op) \\\n Vc_INTRINSIC Vector &operator op##=(AsArg x); \\\n Vc_INTRINSIC Vc_PURE Vector operator op(AsArg x) const \\\n { \\\n static_assert( \\\n std::is_integral::value, \\\n \"bitwise-operators can only be used with Vectors of integral type\"); \\\n }\n Vc_ALL_SHIFTS(Vc_OP_VEC);\n#undef Vc_OP_VEC\n\n Vc_ALWAYS_INLINE_L Vector &operator>>=(int x) Vc_ALWAYS_INLINE_R;\n Vc_ALWAYS_INLINE_L Vector &operator<<=(int x) Vc_ALWAYS_INLINE_R;\n Vc_ALWAYS_INLINE_L Vector operator>>(int x) const Vc_ALWAYS_INLINE_R;\n Vc_ALWAYS_INLINE_L Vector operator<<(int x) const Vc_ALWAYS_INLINE_R;\n\n Vc_DEPRECATED(\"use isnegative(x) instead\") Vc_INTRINSIC Vc_PURE Mask\n isNegative() const\n {\n return Vc::isnegative(*this);\n }\n\n Vc_ALWAYS_INLINE void assign( const Vector &v, const Mask &mask ) {\n data() = Detail::blend(data(), v.data(), mask.data());\n }\n\n template \n Vc_DEPRECATED(\"Use simd_cast instead of Vector::staticCast\") Vc_ALWAYS_INLINE V2\n staticCast() const\n {\n return V2(*this);\n }\n template \n Vc_DEPRECATED(\"use reinterpret_components_cast instead\") Vc_ALWAYS_INLINE V2\n reinterpretCast() const\n {\n return AVX::avx_cast(data());\n }\n\n Vc_ALWAYS_INLINE WriteMaskedVector operator()(const Mask &k)\n {\n return {*this, k};\n }\n\n Vc_ALWAYS_INLINE VectorType &data() { return d.v(); }\n Vc_ALWAYS_INLINE const VectorType &data() const { return d.v(); }\n\n template\n Vc_INTRINSIC_L Vector broadcast() const Vc_INTRINSIC_R;\n\n Vc_INTRINSIC_L std::pair minIndex() const Vc_INTRINSIC_R;\n Vc_INTRINSIC_L std::pair maxIndex() const Vc_INTRINSIC_R;\n\n Vc_ALWAYS_INLINE EntryType min() const { return Detail::min(data(), T()); }\n Vc_ALWAYS_INLINE EntryType max() const { return Detail::max(data(), T()); }\n Vc_ALWAYS_INLINE EntryType product() const { return Detail::mul(data(), T()); }\n Vc_ALWAYS_INLINE EntryType sum() const { return Detail::add(data(), T()); }\n Vc_ALWAYS_INLINE_L Vector partialSum() const Vc_ALWAYS_INLINE_R;\n //template Vc_ALWAYS_INLINE_L Vector partialSum(BinaryOperation op) const Vc_ALWAYS_INLINE_R;\n Vc_ALWAYS_INLINE_L EntryType min(MaskArgument m) const Vc_ALWAYS_INLINE_R;\n Vc_ALWAYS_INLINE_L EntryType max(MaskArgument m) const Vc_ALWAYS_INLINE_R;\n Vc_ALWAYS_INLINE_L EntryType product(MaskArgument m) const Vc_ALWAYS_INLINE_R;\n Vc_ALWAYS_INLINE_L EntryType sum(MaskArgument m) const Vc_ALWAYS_INLINE_R;\n\n Vc_INTRINSIC_L Vector shifted(int amount, Vector shiftIn) const Vc_INTRINSIC_R;\n Vc_INTRINSIC_L Vector shifted(int amount) const Vc_INTRINSIC_R;\n Vc_INTRINSIC_L Vector rotated(int amount) const Vc_INTRINSIC_R;\n Vc_INTRINSIC_L Vc_PURE_L Vector reversed() const Vc_INTRINSIC_R Vc_PURE_R;\n Vc_ALWAYS_INLINE_L Vc_PURE_L Vector sorted() const Vc_ALWAYS_INLINE_R Vc_PURE_R;\n\n template void callWithValuesSorted(F &&f)\n {\n EntryType value = d.m(0);\n f(value);\n for (size_t i = 1; i < Size; ++i) {\n if (d.m(i) != value) {\n value = d.m(i);\n f(value);\n }\n }\n }\n\n template Vc_INTRINSIC void call(F &&f) const\n {\n Common::for_all_vector_entries([&](size_t i) { f(EntryType(d.m(i))); });\n }\n\n template Vc_INTRINSIC void call(F &&f, const Mask &mask) const\n {\n for (size_t i : where(mask)) {\n f(EntryType(d.m(i)));\n }\n }\n\n template Vc_INTRINSIC Vector apply(F &&f) const\n {\n Vector r;\n Common::for_all_vector_entries(\n [&](size_t i) { r.d.set(i, f(EntryType(d.m(i)))); });\n return r;\n }\n\n template Vc_INTRINSIC Vector apply(F &&f, const Mask &mask) const\n {\n Vector r(*this);\n for (size_t i : where(mask)) {\n r.d.set(i, f(EntryType(r.d.m(i))));\n }\n return r;\n }\n\n template Vc_INTRINSIC void fill(EntryType (&f)(IndexT)) {\n Common::for_all_vector_entries([&](size_t i) { d.set(i, f(i)); });\n }\n Vc_INTRINSIC void fill(EntryType (&f)()) {\n Common::for_all_vector_entries([&](size_t i) { d.set(i, f()); });\n }\n\n template static Vc_INTRINSIC_L Vector generate(G gen) Vc_INTRINSIC_R;\n\n Vc_DEPRECATED(\"use copysign(x, y) instead\") Vc_INTRINSIC Vector\n copySign(AsArg x) const\n {\n return Vc::copysign(*this, x);\n }\n\n Vc_DEPRECATED(\"use exponent(x) instead\") Vc_INTRINSIC Vector exponent() const\n {\n Vc::exponent(*this);\n }\n\n Vc_INTRINSIC_L Vector interleaveLow(Vector x) const Vc_INTRINSIC_R;\n Vc_INTRINSIC_L Vector interleaveHigh(Vector x) const Vc_INTRINSIC_R;\n};\n#undef Vc_CURRENT_CLASS_NAME\ntemplate constexpr size_t Vector::Size;\ntemplate constexpr size_t Vector::MemoryAlignment;\n\n#define Vc_CONDITIONAL_ASSIGN(name_, op_) \\\n template \\\n Vc_INTRINSIC enable_if conditional_assign( \\\n AVX2::Vector &lhs, M &&mask, U &&rhs) \\\n { \\\n lhs(mask) op_ rhs; \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\nVc_CONDITIONAL_ASSIGN( Assign, =);\nVc_CONDITIONAL_ASSIGN( PlusAssign, +=);\nVc_CONDITIONAL_ASSIGN( MinusAssign, -=);\nVc_CONDITIONAL_ASSIGN( MultiplyAssign, *=);\nVc_CONDITIONAL_ASSIGN( DivideAssign, /=);\nVc_CONDITIONAL_ASSIGN( RemainderAssign, %=);\nVc_CONDITIONAL_ASSIGN( XorAssign, ^=);\nVc_CONDITIONAL_ASSIGN( AndAssign, &=);\nVc_CONDITIONAL_ASSIGN( OrAssign, |=);\nVc_CONDITIONAL_ASSIGN( LeftShiftAssign,<<=);\nVc_CONDITIONAL_ASSIGN(RightShiftAssign,>>=);\n#undef Vc_CONDITIONAL_ASSIGN\n\n#define Vc_CONDITIONAL_ASSIGN(name_, expr_) \\\n template \\\n Vc_INTRINSIC enable_if> conditional_assign( \\\n AVX2::Vector &lhs, M &&mask) \\\n { \\\n return expr_; \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\nVc_CONDITIONAL_ASSIGN(PostIncrement, lhs(mask)++);\nVc_CONDITIONAL_ASSIGN( PreIncrement, ++lhs(mask));\nVc_CONDITIONAL_ASSIGN(PostDecrement, lhs(mask)--);\nVc_CONDITIONAL_ASSIGN( PreDecrement, --lhs(mask));\n#undef Vc_CONDITIONAL_ASSIGN\n\n} // namespace Vc\n\n#include \"vector.tcc\"\n#include \"simd_cast.h\"\n\n#endif // VC_AVX_VECTOR_H_\n" }, { "path": "3rdparty/Vc/Vc/avx/vector.tcc", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2011-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#include \"../common/x86_prefetches.h\"\n#include \"../common/gatherimplementation.h\"\n#include \"../common/scatterimplementation.h\"\n#include \"limits.h\"\n#include \"const.h\"\n#include \"../common/set.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Detail\n{\n// compare operators {{{1\nVc_INTRINSIC AVX2::double_m operator==(AVX2::double_v a, AVX2::double_v b) { return AVX::cmpeq_pd(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: float_m operator==(AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmpeq_ps(a.data(), b.data()); }\nVc_INTRINSIC AVX2::double_m operator!=(AVX2::double_v a, AVX2::double_v b) { return AVX::cmpneq_pd(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: float_m operator!=(AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmpneq_ps(a.data(), b.data()); }\nVc_INTRINSIC AVX2::double_m operator>=(AVX2::double_v a, AVX2::double_v b) { return AVX::cmpnlt_pd(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: float_m operator>=(AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmpnlt_ps(a.data(), b.data()); }\nVc_INTRINSIC AVX2::double_m operator<=(AVX2::double_v a, AVX2::double_v b) { return AVX::cmple_pd(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: float_m operator<=(AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmple_ps(a.data(), b.data()); }\nVc_INTRINSIC AVX2::double_m operator> (AVX2::double_v a, AVX2::double_v b) { return AVX::cmpgt_pd(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: float_m operator> (AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmpgt_ps(a.data(), b.data()); }\nVc_INTRINSIC AVX2::double_m operator< (AVX2::double_v a, AVX2::double_v b) { return AVX::cmplt_pd(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: float_m operator< (AVX2:: float_v a, AVX2:: float_v b) { return AVX::cmplt_ps(a.data(), b.data()); }\n\n#ifdef Vc_IMPL_AVX2\nVc_INTRINSIC AVX2:: int_m operator==(AVX2:: int_v a, AVX2:: int_v b) { return AVX::cmpeq_epi32(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: uint_m operator==(AVX2:: uint_v a, AVX2:: uint_v b) { return AVX::cmpeq_epi32(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: short_m operator==(AVX2:: short_v a, AVX2:: short_v b) { return AVX::cmpeq_epi16(a.data(), b.data()); }\nVc_INTRINSIC AVX2::ushort_m operator==(AVX2::ushort_v a, AVX2::ushort_v b) { return AVX::cmpeq_epi16(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: int_m operator!=(AVX2:: int_v a, AVX2:: int_v b) { return not_(AVX::cmpeq_epi32(a.data(), b.data())); }\nVc_INTRINSIC AVX2:: uint_m operator!=(AVX2:: uint_v a, AVX2:: uint_v b) { return not_(AVX::cmpeq_epi32(a.data(), b.data())); }\nVc_INTRINSIC AVX2:: short_m operator!=(AVX2:: short_v a, AVX2:: short_v b) { return not_(AVX::cmpeq_epi16(a.data(), b.data())); }\nVc_INTRINSIC AVX2::ushort_m operator!=(AVX2::ushort_v a, AVX2::ushort_v b) { return not_(AVX::cmpeq_epi16(a.data(), b.data())); }\nVc_INTRINSIC AVX2:: int_m operator>=(AVX2:: int_v a, AVX2:: int_v b) { return not_(AVX::cmplt_epi32(a.data(), b.data())); }\nVc_INTRINSIC AVX2:: uint_m operator>=(AVX2:: uint_v a, AVX2:: uint_v b) { return not_(AVX::cmplt_epu32(a.data(), b.data())); }\nVc_INTRINSIC AVX2:: short_m operator>=(AVX2:: short_v a, AVX2:: short_v b) { return not_(AVX::cmplt_epi16(a.data(), b.data())); }\nVc_INTRINSIC AVX2::ushort_m operator>=(AVX2::ushort_v a, AVX2::ushort_v b) { return not_(AVX::cmplt_epu16(a.data(), b.data())); }\nVc_INTRINSIC AVX2:: int_m operator<=(AVX2:: int_v a, AVX2:: int_v b) { return not_(AVX::cmpgt_epi32(a.data(), b.data())); }\nVc_INTRINSIC AVX2:: uint_m operator<=(AVX2:: uint_v a, AVX2:: uint_v b) { return not_(AVX::cmpgt_epu32(a.data(), b.data())); }\nVc_INTRINSIC AVX2:: short_m operator<=(AVX2:: short_v a, AVX2:: short_v b) { return not_(AVX::cmpgt_epi16(a.data(), b.data())); }\nVc_INTRINSIC AVX2::ushort_m operator<=(AVX2::ushort_v a, AVX2::ushort_v b) { return not_(AVX::cmpgt_epu16(a.data(), b.data())); }\nVc_INTRINSIC AVX2:: int_m operator> (AVX2:: int_v a, AVX2:: int_v b) { return AVX::cmpgt_epi32(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: uint_m operator> (AVX2:: uint_v a, AVX2:: uint_v b) { return AVX::cmpgt_epu32(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: short_m operator> (AVX2:: short_v a, AVX2:: short_v b) { return AVX::cmpgt_epi16(a.data(), b.data()); }\nVc_INTRINSIC AVX2::ushort_m operator> (AVX2::ushort_v a, AVX2::ushort_v b) { return AVX::cmpgt_epu16(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: int_m operator< (AVX2:: int_v a, AVX2:: int_v b) { return AVX::cmplt_epi32(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: uint_m operator< (AVX2:: uint_v a, AVX2:: uint_v b) { return AVX::cmplt_epu32(a.data(), b.data()); }\nVc_INTRINSIC AVX2:: short_m operator< (AVX2:: short_v a, AVX2:: short_v b) { return AVX::cmplt_epi16(a.data(), b.data()); }\nVc_INTRINSIC AVX2::ushort_m operator< (AVX2::ushort_v a, AVX2::ushort_v b) { return AVX::cmplt_epu16(a.data(), b.data()); }\n#endif // Vc_IMPL_AVX2\n\n// bitwise operators {{{1\ntemplate \nVc_INTRINSIC AVX2::Vector operator^(AVX2::Vector a, AVX2::Vector b)\n{\n return xor_(a.data(), b.data());\n}\ntemplate \nVc_INTRINSIC AVX2::Vector operator&(AVX2::Vector a, AVX2::Vector b)\n{\n return and_(a.data(), b.data());\n}\ntemplate \nVc_INTRINSIC AVX2::Vector operator|(AVX2::Vector a, AVX2::Vector b)\n{\n return or_(a.data(), b.data());\n}\n// }}}1\n// arithmetic operators {{{1\ntemplate \nVc_INTRINSIC AVX2::Vector operator+(AVX2::Vector a, AVX2::Vector b)\n{\n return add(a.data(), b.data(), T());\n}\ntemplate \nVc_INTRINSIC AVX2::Vector operator-(AVX2::Vector a, AVX2::Vector b)\n{\n return sub(a.data(), b.data(), T());\n}\ntemplate \nVc_INTRINSIC AVX2::Vector operator*(AVX2::Vector a, AVX2::Vector b)\n{\n return mul(a.data(), b.data(), T());\n}\ntemplate \nVc_INTRINSIC AVX2::Vector operator/(AVX2::Vector a, AVX2::Vector b)\n{\n return div(a.data(), b.data(), T());\n}\nVc_INTRINSIC AVX2::Vector operator/(AVX2::Vector a,\n AVX2::Vector b)\n{\n using namespace AVX;\n const __m256 lo = _mm256_div_ps(convert(lo128(a.data())),\n convert(lo128(b.data())));\n const __m256 hi = _mm256_div_ps(convert(hi128(a.data())),\n convert(hi128(b.data())));\n const float_v threshold = 32767.f;\n using Detail::operator>;\n const __m128i loShort = (Vc_IS_UNLIKELY((float_v(lo) > threshold).isNotEmpty()))\n ? convert(lo)\n : convert(lo);\n const __m128i hiShort = (Vc_IS_UNLIKELY((float_v(hi) > threshold).isNotEmpty()))\n ? convert(hi)\n : convert(hi);\n return concat(loShort, hiShort);\n}\ntemplate \nVc_INTRINSIC enable_if::value, AVX2::Vector> operator%(\n AVX2::Vector a, AVX2::Vector b)\n{\n return a - a / b * b;\n}\n// }}}1\n} // namespace Detail\n///////////////////////////////////////////////////////////////////////////////////////////\n// generate {{{1\ntemplate <> template Vc_INTRINSIC AVX2::double_v AVX2::double_v::generate(G gen)\n{\n const auto tmp0 = gen(0);\n const auto tmp1 = gen(1);\n const auto tmp2 = gen(2);\n const auto tmp3 = gen(3);\n return _mm256_setr_pd(tmp0, tmp1, tmp2, tmp3);\n}\ntemplate <> template Vc_INTRINSIC AVX2::float_v AVX2::float_v::generate(G gen)\n{\n const auto tmp0 = gen(0);\n const auto tmp1 = gen(1);\n const auto tmp2 = gen(2);\n const auto tmp3 = gen(3);\n const auto tmp4 = gen(4);\n const auto tmp5 = gen(5);\n const auto tmp6 = gen(6);\n const auto tmp7 = gen(7);\n return _mm256_setr_ps(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);\n}\n#ifdef Vc_IMPL_AVX2\ntemplate <> template Vc_INTRINSIC AVX2::int_v AVX2::int_v::generate(G gen)\n{\n const auto tmp0 = gen(0);\n const auto tmp1 = gen(1);\n const auto tmp2 = gen(2);\n const auto tmp3 = gen(3);\n const auto tmp4 = gen(4);\n const auto tmp5 = gen(5);\n const auto tmp6 = gen(6);\n const auto tmp7 = gen(7);\n return _mm256_setr_epi32(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);\n}\ntemplate <> template Vc_INTRINSIC AVX2::uint_v AVX2::uint_v::generate(G gen)\n{\n const auto tmp0 = gen(0);\n const auto tmp1 = gen(1);\n const auto tmp2 = gen(2);\n const auto tmp3 = gen(3);\n const auto tmp4 = gen(4);\n const auto tmp5 = gen(5);\n const auto tmp6 = gen(6);\n const auto tmp7 = gen(7);\n return _mm256_setr_epi32(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);\n}\ntemplate <> template Vc_INTRINSIC AVX2::short_v AVX2::short_v::generate(G gen)\n{\n const auto tmp0 = gen(0);\n const auto tmp1 = gen(1);\n const auto tmp2 = gen(2);\n const auto tmp3 = gen(3);\n const auto tmp4 = gen(4);\n const auto tmp5 = gen(5);\n const auto tmp6 = gen(6);\n const auto tmp7 = gen(7);\n const auto tmp8 = gen(8);\n const auto tmp9 = gen(9);\n const auto tmp10 = gen(10);\n const auto tmp11 = gen(11);\n const auto tmp12 = gen(12);\n const auto tmp13 = gen(13);\n const auto tmp14 = gen(14);\n const auto tmp15 = gen(15);\n return _mm256_setr_epi16(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15);\n}\ntemplate <> template Vc_INTRINSIC AVX2::ushort_v AVX2::ushort_v::generate(G gen)\n{\n const auto tmp0 = gen(0);\n const auto tmp1 = gen(1);\n const auto tmp2 = gen(2);\n const auto tmp3 = gen(3);\n const auto tmp4 = gen(4);\n const auto tmp5 = gen(5);\n const auto tmp6 = gen(6);\n const auto tmp7 = gen(7);\n const auto tmp8 = gen(8);\n const auto tmp9 = gen(9);\n const auto tmp10 = gen(10);\n const auto tmp11 = gen(11);\n const auto tmp12 = gen(12);\n const auto tmp13 = gen(13);\n const auto tmp14 = gen(14);\n const auto tmp15 = gen(15);\n return _mm256_setr_epi16(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15);\n}\n#endif\n\n// constants {{{1\ntemplate Vc_INTRINSIC Vector::Vector(VectorSpecialInitializerZero) : d{} {}\n\ntemplate <> Vc_INTRINSIC Vector::Vector(VectorSpecialInitializerOne) : d(AVX::setone_pd()) {}\ntemplate <> Vc_INTRINSIC Vector< float, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_ps()) {}\n#ifdef Vc_IMPL_AVX2\ntemplate <> Vc_INTRINSIC Vector< int, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epi32()) {}\ntemplate <> Vc_INTRINSIC Vector< uint, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epu32()) {}\ntemplate <> Vc_INTRINSIC Vector< short, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epi16()) {}\ntemplate <> Vc_INTRINSIC Vector::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epu16()) {}\ntemplate <> Vc_INTRINSIC Vector< schar, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epi8()) {}\ntemplate <> Vc_INTRINSIC Vector< uchar, VectorAbi::Avx>::Vector(VectorSpecialInitializerOne) : d(AVX::setone_epu8()) {}\n#endif\n\ntemplate \nVc_ALWAYS_INLINE Vector::Vector(\n VectorSpecialInitializerIndexesFromZero)\n : Vector(AVX::IndexesFromZeroData::address(), Vc::Aligned)\n{\n}\n\ntemplate <>\nVc_ALWAYS_INLINE Vector::Vector(VectorSpecialInitializerIndexesFromZero)\n : Vector(AVX::IndexesFromZeroData::address(), Vc::Aligned)\n{\n}\ntemplate <>\nVc_ALWAYS_INLINE Vector::Vector(VectorSpecialInitializerIndexesFromZero)\n : Vector(AVX::IndexesFromZeroData::address(), Vc::Aligned)\n{\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////\n// load member functions {{{1\n// general load, implemented via LoadHelper {{{2\ntemplate \ntemplate \nVc_INTRINSIC typename Vector::\n#ifndef Vc_MSVC\ntemplate\n#endif\nload_concept::type Vector::load(const SrcT *mem, Flags flags)\n{\n Common::handleLoadPrefetches(mem, flags);\n d.v() = Detail::load(mem, flags);\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////\n// zeroing {{{1\ntemplate Vc_INTRINSIC void Vector::setZero()\n{\n data() = Detail::zero();\n}\ntemplate Vc_INTRINSIC void Vector::setZero(const Mask &k)\n{\n data() = Detail::andnot_(k.data(), data());\n}\ntemplate Vc_INTRINSIC void Vector::setZeroInverted(const Mask &k)\n{\n data() = Detail::and_(k.data(), data());\n}\n\ntemplate<> Vc_INTRINSIC void Vector::setQnan()\n{\n data() = Detail::allone();\n}\ntemplate<> Vc_INTRINSIC void Vector::setQnan(MaskArgument k)\n{\n data() = _mm256_or_pd(data(), k.dataD());\n}\ntemplate<> Vc_INTRINSIC void Vector::setQnan()\n{\n data() = Detail::allone();\n}\ntemplate<> Vc_INTRINSIC void Vector::setQnan(MaskArgument k)\n{\n data() = _mm256_or_ps(data(), k.dataF());\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////\n// stores {{{1\ntemplate \ntemplate \nVc_INTRINSIC void Vector::store(U *mem, Flags flags) const\n{\n Common::handleStorePrefetches(mem, flags);\n HV::template store(mem, data());\n}\n\ntemplate \ntemplate \nVc_INTRINSIC void Vector::store(U *mem, Mask mask, Flags flags) const\n{\n Common::handleStorePrefetches(mem, flags);\n HV::template store(mem, data(), mask.data());\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////\n// integer ops {{{1\n#ifdef Vc_IMPL_AVX2\ntemplate <> Vc_ALWAYS_INLINE AVX2::Vector< int> Vector< int, VectorAbi::Avx>::operator<<(AsArg x) const { return _mm256_sllv_epi32(d.v(), x.d.v()); }\ntemplate <> Vc_ALWAYS_INLINE AVX2::Vector< uint> Vector< uint, VectorAbi::Avx>::operator<<(AsArg x) const { return _mm256_sllv_epi32(d.v(), x.d.v()); }\ntemplate <> Vc_ALWAYS_INLINE AVX2::Vector< int> Vector< int, VectorAbi::Avx>::operator>>(AsArg x) const { return _mm256_srav_epi32(d.v(), x.d.v()); }\ntemplate <> Vc_ALWAYS_INLINE AVX2::Vector< uint> Vector< uint, VectorAbi::Avx>::operator>>(AsArg x) const { return _mm256_srlv_epi32(d.v(), x.d.v()); }\ntemplate <> Vc_ALWAYS_INLINE AVX2::Vector< short> Vector< short, VectorAbi::Avx>::operator<<(AsArg x) const { return generate([&](int i) { return get(*this, i) << get(x, i); }); }\ntemplate <> Vc_ALWAYS_INLINE AVX2::Vector Vector::operator<<(AsArg x) const { return generate([&](int i) { return get(*this, i) << get(x, i); }); }\ntemplate <> Vc_ALWAYS_INLINE AVX2::Vector< short> Vector< short, VectorAbi::Avx>::operator>>(AsArg x) const { return generate([&](int i) { return get(*this, i) >> get(x, i); }); }\ntemplate <> Vc_ALWAYS_INLINE AVX2::Vector Vector::operator>>(AsArg x) const { return generate([&](int i) { return get(*this, i) >> get(x, i); }); }\ntemplate \nVc_ALWAYS_INLINE AVX2::Vector &Vector::operator<<=(AsArg x)\n{\n static_assert(std::is_integral::value,\n \"bitwise-operators can only be used with Vectors of integral type\");\n return *this = *this << x;\n}\ntemplate \nVc_ALWAYS_INLINE AVX2::Vector &Vector::operator>>=(AsArg x)\n{\n static_assert(std::is_integral::value,\n \"bitwise-operators can only be used with Vectors of integral type\");\n return *this = *this >> x;\n}\n#endif\n\ntemplate Vc_ALWAYS_INLINE AVX2::Vector &Vector::operator>>=(int shift) {\n d.v() = Detail::shiftRight(d.v(), shift, T());\n return *static_cast *>(this);\n}\ntemplate Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector Vector::operator>>(int shift) const {\n return Detail::shiftRight(d.v(), shift, T());\n}\ntemplate Vc_ALWAYS_INLINE AVX2::Vector &Vector::operator<<=(int shift) {\n d.v() = Detail::shiftLeft(d.v(), shift, T());\n return *static_cast *>(this);\n}\ntemplate Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector Vector::operator<<(int shift) const {\n return Detail::shiftLeft(d.v(), shift, T());\n}\n\n// isnegative {{{1\nVc_INTRINSIC Vc_CONST AVX2::float_m isnegative(AVX2::float_v x)\n{\n return AVX::avx_cast<__m256>(AVX::srai_epi32<31>(\n AVX::avx_cast<__m256i>(_mm256_and_ps(AVX::setsignmask_ps(), x.data()))));\n}\nVc_INTRINSIC Vc_CONST AVX2::double_m isnegative(AVX2::double_v x)\n{\n return Mem::permute(AVX::avx_cast<__m256>(AVX::srai_epi32<31>(\n AVX::avx_cast<__m256i>(_mm256_and_pd(AVX::setsignmask_pd(), x.data())))));\n}\n// gathers {{{1\n#define Vc_GATHER_IMPL(V_) \\\n template <> \\\n template \\\n inline void AVX2::V_::gatherImplementation( \\\n const Common::GatherArguments &args)\n#define Vc_M(i_) static_cast(args.address[Scale * args.indexes[i_]])\nVc_GATHER_IMPL(double_v) { d.v() = _mm256_setr_pd(Vc_M(0), Vc_M(1), Vc_M(2), Vc_M(3)); }\n\nVc_GATHER_IMPL(float_v)\n{\n d.v() = _mm256_setr_ps(Vc_M(0), Vc_M(1), Vc_M(2), Vc_M(3), Vc_M(4), Vc_M(5), Vc_M(6),\n Vc_M(7));\n}\n\n#ifdef Vc_IMPL_AVX2\nVc_GATHER_IMPL(int_v)\n{\n d.v() = _mm256_setr_epi32(Vc_M(0), Vc_M(1), Vc_M(2), Vc_M(3), Vc_M(4), Vc_M(5),\n Vc_M(6), Vc_M(7));\n}\n\nVc_GATHER_IMPL(uint_v)\n{\n d.v() = _mm256_setr_epi32(Vc_M(0), Vc_M(1), Vc_M(2), Vc_M(3), Vc_M(4), Vc_M(5),\n Vc_M(6), Vc_M(7));\n}\n\nVc_GATHER_IMPL(short_v)\n{\n d.v() = _mm256_setr_epi16(Vc_M(0), Vc_M(1), Vc_M(2), Vc_M(3), Vc_M(4), Vc_M(5),\n Vc_M(6), Vc_M(7), Vc_M(8), Vc_M(9), Vc_M(10), Vc_M(11),\n Vc_M(12), Vc_M(13), Vc_M(14), Vc_M(15));\n}\n\nVc_GATHER_IMPL(ushort_v)\n{\n d.v() = _mm256_setr_epi16(Vc_M(0), Vc_M(1), Vc_M(2), Vc_M(3), Vc_M(4), Vc_M(5),\n Vc_M(6), Vc_M(7), Vc_M(8), Vc_M(9), Vc_M(10), Vc_M(11),\n Vc_M(12), Vc_M(13), Vc_M(14), Vc_M(15));\n}\n#endif\n#undef Vc_M\n#undef Vc_GATHER_IMPL\n\ntemplate \ntemplate \ninline void Vector::gatherImplementation(\n const Common::GatherArguments &args, MaskArgument mask)\n{\n const auto *mem = args.address;\n const auto indexes = Scale * args.indexes;\n using Selector = std::integral_constant < Common::GatherScatterImplementation,\n#ifdef Vc_USE_SET_GATHERS\n Traits::is_simd_vector::value ? Common::GatherScatterImplementation::SetIndexZero :\n#endif\n#ifdef Vc_USE_BSF_GATHERS\n Common::GatherScatterImplementation::BitScanLoop\n#elif defined Vc_USE_POPCNT_BSF_GATHERS\n Common::GatherScatterImplementation::PopcntSwitch\n#else\n Common::GatherScatterImplementation::SimpleLoop\n#endif\n > ;\n Common::executeGather(Selector(), *this, mem, indexes, mask);\n}\n\ntemplate \ntemplate \ninline void Vector::scatterImplementation(MT *mem, IT &&indexes) const\n{\n Common::unrolled_loop([&](std::size_t i) { mem[indexes[i]] = d.m(i); });\n}\n\ntemplate \ntemplate \ninline void Vector::scatterImplementation(MT *mem, IT &&indexes, MaskArgument mask) const\n{\n using Selector = std::integral_constant < Common::GatherScatterImplementation,\n#ifdef Vc_USE_SET_GATHERS\n Traits::is_simd_vector::value ? Common::GatherScatterImplementation::SetIndexZero :\n#endif\n#ifdef Vc_USE_BSF_GATHERS\n Common::GatherScatterImplementation::BitScanLoop\n#elif defined Vc_USE_POPCNT_BSF_GATHERS\n Common::GatherScatterImplementation::PopcntSwitch\n#else\n Common::GatherScatterImplementation::SimpleLoop\n#endif\n > ;\n Common::executeScatter(Selector(), *this, mem, std::forward(indexes), mask);\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////\n// operator- {{{1\n#ifdef Vc_USE_BUILTIN_VECTOR_TYPES\ntemplate Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector Vector::operator-() const\n{\n return VectorType(-d.builtin());\n}\n#else\ntemplate Vc_ALWAYS_INLINE Vc_PURE AVX2::Vector Vector::operator-() const\n{\n return Detail::negate(d.v(), std::integral_constant());\n}\n#endif\n\n///////////////////////////////////////////////////////////////////////////////////////////\n// horizontal ops {{{1\ntemplate \nVc_INTRINSIC std::pair, int>\nVector::minIndex() const\n{\n AVX2::Vector x = min();\n return std::make_pair(x, (*this == x).firstOne());\n}\ntemplate \nVc_INTRINSIC std::pair, int>\nVector::maxIndex() const\n{\n AVX2::Vector x = max();\n return std::make_pair(x, (*this == x).firstOne());\n}\ntemplate <> Vc_INTRINSIC std::pair AVX2::float_v::minIndex() const\n{\n /*\n // 28 cycles latency:\n __m256 x = _mm256_min_ps(Mem::permute128(d.v()), d.v());\n x = _mm256_min_ps(x, Reg::permute(x));\n AVX2::float_v xx = _mm256_min_ps(x, Reg::permute(x));\n AVX2::uint_v idx = AVX2::uint_v::IndexesFromZero();\n idx = _mm256_castps_si256(\n _mm256_or_ps((*this != xx).data(), _mm256_castsi256_ps(idx.data())));\n return std::make_pair(xx, (*this == xx).firstOne());\n\n __m128 loData = AVX::lo128(d.v());\n __m128 hiData = AVX::hi128(d.v());\n const __m128 less2 = _mm_cmplt_ps(hiData, loData);\n loData = _mm_min_ps(loData, hiData);\n hiData = Mem::permute(loData);\n const __m128 less1 = _mm_cmplt_ps(hiData, loData);\n loData = _mm_min_ps(loData, hiData);\n hiData = Mem::permute(loData);\n const __m128 less0 = _mm_cmplt_ps(hiData, loData);\n unsigned bits = _mm_movemask_ps(less0) & 0x1;\n bits |= ((_mm_movemask_ps(less1) << 1) - bits) & 0x2;\n bits |= ((_mm_movemask_ps(less2) << 3) - bits) & 0x4;\n loData = _mm_min_ps(loData, hiData);\n return std::make_pair(AVX::concat(loData, loData), bits);\n */\n\n // 28 cycles Latency:\n __m256 x = d.v();\n __m256 idx = Vector::IndexesFromZero().data();\n __m256 y = Mem::permute128(x);\n __m256 idy = Mem::permute128(idx);\n __m256 less = AVX::cmplt_ps(x, y);\n\n x = _mm256_blendv_ps(y, x, less);\n idx = _mm256_blendv_ps(idy, idx, less);\n y = Reg::permute(x);\n idy = Reg::permute(idx);\n less = AVX::cmplt_ps(x, y);\n\n x = _mm256_blendv_ps(y, x, less);\n idx = _mm256_blendv_ps(idy, idx, less);\n y = Reg::permute(x);\n idy = Reg::permute(idx);\n less = AVX::cmplt_ps(x, y);\n\n idx = _mm256_blendv_ps(idy, idx, less);\n\n const auto index = _mm_cvtsi128_si32(AVX::avx_cast<__m128i>(idx));\n#ifdef Vc_GNU_ASM\n __asm__ __volatile__(\"\"); // help GCC to order the instructions better\n#endif\n x = _mm256_blendv_ps(y, x, less);\n return std::make_pair(x, index);\n}\ntemplate Vc_ALWAYS_INLINE AVX2::Vector Vector::partialSum() const\n{\n // a b c d e f g h\n // + a b c d e f g -> a ab bc cd de ef fg gh\n // + a ab bc cd de ef -> a ab abc abcd bcde cdef defg efgh\n // + a ab abc abcd -> a ab abc abcd abcde abcdef abcdefg abcdefgh\n AVX2::Vector tmp = *this;\n if (Size > 1) tmp += tmp.shifted(-1);\n if (Size > 2) tmp += tmp.shifted(-2);\n if (Size > 4) tmp += tmp.shifted(-4);\n if (Size > 8) tmp += tmp.shifted(-8);\n if (Size > 16) tmp += tmp.shifted(-16);\n return tmp;\n}\n\n/* This function requires correct masking because the neutral element of \\p op is not necessarily 0\n *\ntemplate template Vc_ALWAYS_INLINE AVX2::Vector Vector::partialSum(BinaryOperation op) const\n{\n // a b c d e f g h\n // + a b c d e f g -> a ab bc cd de ef fg gh\n // + a ab bc cd de ef -> a ab abc abcd bcde cdef defg efgh\n // + a ab abc abcd -> a ab abc abcd abcde abcdef abcdefg abcdefgh\n AVX2::Vector tmp = *this;\n Mask mask(true);\n if (Size > 1) tmp(mask) = op(tmp, tmp.shifted(-1));\n if (Size > 2) tmp(mask) = op(tmp, tmp.shifted(-2));\n if (Size > 4) tmp(mask) = op(tmp, tmp.shifted(-4));\n if (Size > 8) tmp(mask) = op(tmp, tmp.shifted(-8));\n if (Size > 16) tmp(mask) = op(tmp, tmp.shifted(-16));\n return tmp;\n}\n*/\n\ntemplate Vc_ALWAYS_INLINE typename Vector::EntryType Vector::min(MaskArgument m) const\n{\n AVX2::Vector tmp = std::numeric_limits >::max();\n tmp(m) = *this;\n return tmp.min();\n}\ntemplate Vc_ALWAYS_INLINE typename Vector::EntryType Vector::max(MaskArgument m) const\n{\n AVX2::Vector tmp = std::numeric_limits >::min();\n tmp(m) = *this;\n return tmp.max();\n}\ntemplate Vc_ALWAYS_INLINE typename Vector::EntryType Vector::product(MaskArgument m) const\n{\n AVX2::Vector tmp(Vc::One);\n tmp(m) = *this;\n return tmp.product();\n}\ntemplate Vc_ALWAYS_INLINE typename Vector::EntryType Vector::sum(MaskArgument m) const\n{\n AVX2::Vector tmp(Vc::Zero);\n tmp(m) = *this;\n return tmp.sum();\n}//}}}\n// exponent {{{1\nnamespace Detail\n{\nVc_INTRINSIC Vc_CONST __m256 exponent(__m256 v)\n{\n using namespace AVX;\n __m128i tmp0 = _mm_srli_epi32(avx_cast<__m128i>(v), 23);\n __m128i tmp1 = _mm_srli_epi32(avx_cast<__m128i>(hi128(v)), 23);\n tmp0 = _mm_sub_epi32(tmp0, _mm_set1_epi32(0x7f));\n tmp1 = _mm_sub_epi32(tmp1, _mm_set1_epi32(0x7f));\n return _mm256_cvtepi32_ps(concat(tmp0, tmp1));\n}\nVc_INTRINSIC Vc_CONST __m256d exponent(__m256d v)\n{\n using namespace AVX;\n __m128i tmp0 = _mm_srli_epi64(avx_cast<__m128i>(v), 52);\n __m128i tmp1 = _mm_srli_epi64(avx_cast<__m128i>(hi128(v)), 52);\n tmp0 = _mm_sub_epi32(tmp0, _mm_set1_epi32(0x3ff));\n tmp1 = _mm_sub_epi32(tmp1, _mm_set1_epi32(0x3ff));\n return _mm256_cvtepi32_pd(avx_cast<__m128i>(Mem::shuffle(avx_cast<__m128>(tmp0), avx_cast<__m128>(tmp1))));\n}\n} // namespace Detail\n\nVc_INTRINSIC Vc_CONST AVX2::float_v exponent(AVX2::float_v x)\n{\n using Detail::operator>=;\n Vc_ASSERT((x >= x.Zero()).isFull());\n return Detail::exponent(x.data());\n}\nVc_INTRINSIC Vc_CONST AVX2::double_v exponent(AVX2::double_v x)\n{\n using Detail::operator>=;\n Vc_ASSERT((x >= x.Zero()).isFull());\n return Detail::exponent(x.data());\n}\n// }}}1\n// Random {{{1\nstatic Vc_ALWAYS_INLINE __m256i _doRandomStep()\n{\n using Detail::operator*;\n using Detail::operator+;\n#ifdef Vc_IMPL_AVX2\n using AVX2::uint_v;\n uint_v state0(&Common::RandomState[0]);\n uint_v state1(&Common::RandomState[uint_v::Size]);\n (state1 * uint_v(0xdeece66du) + uint_v(11)).store(&Common::RandomState[uint_v::Size]);\n uint_v(Detail::xor_((state0 * uint_v(0xdeece66du) + uint_v(11)).data(),\n _mm256_srli_epi32(state1.data(), 16)))\n .store(&Common::RandomState[0]);\n return state0.data();\n#else\n using SSE::uint_v;\n uint_v state0(&Common::RandomState[0]);\n uint_v state1(&Common::RandomState[uint_v::Size]);\n uint_v state2(&Common::RandomState[2 * uint_v::Size]);\n uint_v state3(&Common::RandomState[3 * uint_v::Size]);\n (state2 * uint_v(0xdeece66du) + uint_v(11))\n .store(&Common::RandomState[2 * uint_v::Size]);\n (state3 * uint_v(0xdeece66du) + uint_v(11))\n .store(&Common::RandomState[3 * uint_v::Size]);\n uint_v(Detail::xor_((state0 * uint_v(0xdeece66du) + uint_v(11)).data(),\n _mm_srli_epi32(state2.data(), 16)))\n .store(&Common::RandomState[0]);\n uint_v(Detail::xor_((state1 * uint_v(0xdeece66du) + uint_v(11)).data(),\n _mm_srli_epi32(state3.data(), 16)))\n .store(&Common::RandomState[uint_v::Size]);\n return AVX::concat(state0.data(), state1.data());\n#endif\n}\n\n#ifdef Vc_IMPL_AVX2\ntemplate Vc_ALWAYS_INLINE AVX2::Vector Vector::Random()\n{\n return {_doRandomStep()};\n}\n#endif\n\ntemplate <> Vc_ALWAYS_INLINE AVX2::float_v AVX2::float_v::Random()\n{\n return HT::sub(Detail::or_(_cast(AVX::srli_epi32<2>(_doRandomStep())), HT::one()),\n HT::one());\n}\n\ntemplate<> Vc_ALWAYS_INLINE AVX2::double_v AVX2::double_v::Random()\n{\n const __m256i state = Detail::load(&Common::RandomState[0], Vc::Aligned,\n Detail::LoadTag<__m256i, int>());\n for (size_t k = 0; k < 8; k += 2) {\n typedef unsigned long long uint64 Vc_MAY_ALIAS;\n const uint64 stateX = *aliasing_cast(&Common::RandomState[k]);\n *aliasing_cast(&Common::RandomState[k]) = (stateX * 0x5deece66dull + 11);\n }\n return HT::sub(Detail::or_(_cast(AVX::srli_epi64<12>(state)), HT::one()), HT::one());\n}\n// }}}1\n// shifted / rotated {{{1\ntemplate Vc_INTRINSIC AVX2::Vector Vector::shifted(int amount) const\n{\n return Detail::shifted(d.v(), amount);\n}\n\ntemplate \nVc_INTRINSIC Vc_CONST VectorType shifted_shortcut(VectorType left, VectorType right, Common::WidthT<__m128>)\n{\n return Mem::shuffle(left, right);\n}\ntemplate \nVc_INTRINSIC Vc_CONST VectorType shifted_shortcut(VectorType left, VectorType right, Common::WidthT<__m256>)\n{\n return Mem::shuffle128(left, right);\n}\n\ntemplate Vc_INTRINSIC AVX2::Vector Vector::shifted(int amount, Vector shiftIn) const\n{\n#ifdef __GNUC__\n if (__builtin_constant_p(amount)) {\n const __m256i a = AVX::avx_cast<__m256i>(d.v());\n const __m256i b = AVX::avx_cast<__m256i>(shiftIn.d.v());\n if (amount * 2 == int(Size)) {\n return shifted_shortcut(d.v(), shiftIn.d.v(), WidthT());\n }\n if (amount * 2 == -int(Size)) {\n return shifted_shortcut(shiftIn.d.v(), d.v(), WidthT());\n }\n switch (amount) {\n case 1:\n return AVX::avx_cast(\n#ifdef Vc_IMPL_AVX2\n _mm256_alignr_epi8(_mm256_permute2x128_si256(a, b, 0x21), a,\n sizeof(EntryType))\n#else // Vc_IMPL_AVX2\n AVX::concat(\n _mm_alignr_epi8(AVX::hi128(a), AVX::lo128(a), sizeof(EntryType)),\n _mm_alignr_epi8(AVX::lo128(b), AVX::hi128(a), sizeof(EntryType)))\n#endif // Vc_IMPL_AVX2\n );\n case 2:\n return AVX::avx_cast(\n#ifdef Vc_IMPL_AVX2\n _mm256_alignr_epi8(_mm256_permute2x128_si256(a, b, 0x21), a,\n 2 * sizeof(EntryType))\n#else // Vc_IMPL_AVX2\n AVX::concat(\n _mm_alignr_epi8(AVX::hi128(a), AVX::lo128(a), 2 * sizeof(EntryType)),\n _mm_alignr_epi8(AVX::lo128(b), AVX::hi128(a), 2 * sizeof(EntryType)))\n#endif // Vc_IMPL_AVX2\n );\n case 3:\n if (6u < Size) {\n return AVX::avx_cast(\n#ifdef Vc_IMPL_AVX2\n _mm256_alignr_epi8(_mm256_permute2x128_si256(a, b, 0x21), a,\n 3 * sizeof(EntryType))\n#else // Vc_IMPL_AVX2\n AVX::concat(_mm_alignr_epi8(AVX::hi128(a), AVX::lo128(a),\n 3 * sizeof(EntryType)),\n _mm_alignr_epi8(AVX::lo128(b), AVX::hi128(a),\n 3 * sizeof(EntryType)))\n#endif // Vc_IMPL_AVX2\n );\n // TODO: } else {\n }\n }\n }\n#endif\n using Detail::operator|;\n return shifted(amount) | (amount > 0 ?\n shiftIn.shifted(amount - Size) :\n shiftIn.shifted(Size + amount));\n}\ntemplate Vc_INTRINSIC AVX2::Vector Vector::rotated(int amount) const\n{\n return Detail::rotated(d.v(), amount);\n}\n// sorted {{{1\ntemplate \nVc_ALWAYS_INLINE Vc_PURE Vector Vector::sorted()\n const\n{\n return Detail::sorted(*this);\n}\n// interleaveLow/-High {{{1\ntemplate <> Vc_INTRINSIC AVX2::double_v AVX2::double_v::interleaveLow(AVX2::double_v x) const\n{\n return Mem::shuffle128(_mm256_unpacklo_pd(data(), x.data()),\n _mm256_unpackhi_pd(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::double_v AVX2::double_v::interleaveHigh(AVX2::double_v x) const\n{\n return Mem::shuffle128(_mm256_unpacklo_pd(data(), x.data()),\n _mm256_unpackhi_pd(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::float_v AVX2::float_v::interleaveLow(AVX2::float_v x) const\n{\n return Mem::shuffle128(_mm256_unpacklo_ps(data(), x.data()),\n _mm256_unpackhi_ps(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::float_v AVX2::float_v::interleaveHigh(AVX2::float_v x) const\n{\n return Mem::shuffle128(_mm256_unpacklo_ps(data(), x.data()),\n _mm256_unpackhi_ps(data(), x.data()));\n}\n#ifdef Vc_IMPL_AVX2\ntemplate <> Vc_INTRINSIC AVX2::int_v AVX2::int_v::interleaveLow ( AVX2::int_v x) const {\n return Mem::shuffle128(_mm256_unpacklo_epi32(data(), x.data()),\n _mm256_unpackhi_epi32(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::int_v AVX2::int_v::interleaveHigh( AVX2::int_v x) const {\n return Mem::shuffle128(_mm256_unpacklo_epi32(data(), x.data()),\n _mm256_unpackhi_epi32(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::uint_v AVX2::uint_v::interleaveLow ( AVX2::uint_v x) const {\n return Mem::shuffle128(_mm256_unpacklo_epi32(data(), x.data()),\n _mm256_unpackhi_epi32(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::uint_v AVX2::uint_v::interleaveHigh( AVX2::uint_v x) const {\n return Mem::shuffle128(_mm256_unpacklo_epi32(data(), x.data()),\n _mm256_unpackhi_epi32(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::short_v AVX2::short_v::interleaveLow ( AVX2::short_v x) const {\n return Mem::shuffle128(_mm256_unpacklo_epi16(data(), x.data()),\n _mm256_unpackhi_epi16(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::short_v AVX2::short_v::interleaveHigh( AVX2::short_v x) const {\n return Mem::shuffle128(_mm256_unpacklo_epi16(data(), x.data()),\n _mm256_unpackhi_epi16(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::ushort_v AVX2::ushort_v::interleaveLow (AVX2::ushort_v x) const {\n return Mem::shuffle128(_mm256_unpacklo_epi16(data(), x.data()),\n _mm256_unpackhi_epi16(data(), x.data()));\n}\ntemplate <> Vc_INTRINSIC AVX2::ushort_v AVX2::ushort_v::interleaveHigh(AVX2::ushort_v x) const {\n return Mem::shuffle128(_mm256_unpacklo_epi16(data(), x.data()),\n _mm256_unpackhi_epi16(data(), x.data()));\n}\n#endif\n// permutation via operator[] {{{1\ntemplate <> Vc_INTRINSIC Vc_PURE AVX2::double_v AVX2::double_v::operator[](Permutation::ReversedTag) const\n{\n return Mem::permute128(Mem::permute(d.v()));\n}\ntemplate <> Vc_INTRINSIC Vc_PURE AVX2::float_v AVX2::float_v::operator[](Permutation::ReversedTag) const\n{\n return Mem::permute128(Mem::permute(d.v()));\n}\n#ifdef Vc_IMPL_AVX2\ntemplate <>\nVc_INTRINSIC Vc_PURE AVX2::int_v AVX2::int_v::operator[](Permutation::ReversedTag) const\n{\n return Mem::permute128(Mem::permute(d.v()));\n}\ntemplate <>\nVc_INTRINSIC Vc_PURE AVX2::uint_v AVX2::uint_v::operator[](Permutation::ReversedTag) const\n{\n return Mem::permute128(Mem::permute(d.v()));\n}\ntemplate <>\nVc_INTRINSIC Vc_PURE AVX2::short_v AVX2::short_v::operator[](\n Permutation::ReversedTag) const\n{\n return Mem::permute128(AVX::avx_cast<__m256i>(Mem::shuffle(\n AVX::avx_cast<__m256d>(Mem::permuteHi(d.v())),\n AVX::avx_cast<__m256d>(Mem::permuteLo(d.v())))));\n}\ntemplate <>\nVc_INTRINSIC Vc_PURE AVX2::ushort_v AVX2::ushort_v::operator[](\n Permutation::ReversedTag) const\n{\n return Mem::permute128(AVX::avx_cast<__m256i>(Mem::shuffle(\n AVX::avx_cast<__m256d>(Mem::permuteHi(d.v())),\n AVX::avx_cast<__m256d>(Mem::permuteLo(d.v())))));\n}\n#endif\ntemplate <> Vc_INTRINSIC AVX2::float_v Vector::operator[](const IndexType &/*perm*/) const\n{\n // TODO\n return *this;\n#ifdef Vc_IMPL_AVX2\n#else\n /*\n const int_m cross128 = AVX::concat(_mm_cmpgt_epi32(AVX::lo128(perm.data()), _mm_set1_epi32(3)),\n _mm_cmplt_epi32(AVX::hi128(perm.data()), _mm_set1_epi32(4)));\n if (cross128.isNotEmpty()) {\n AVX2::float_v x = _mm256_permutevar_ps(d.v(), perm.data());\n x(cross128) = _mm256_permutevar_ps(Mem::permute128(d.v()), perm.data());\n return x;\n } else {\n */\n#endif\n}\n\n// reversed {{{1\ntemplate \nVc_INTRINSIC Vc_PURE Vector Vector::reversed() const\n{\n return (*this)[Permutation::Reversed];\n}\n\n// broadcast from constexpr index {{{1\ntemplate <> template Vc_INTRINSIC AVX2::float_v AVX2::float_v::broadcast() const\n{\n constexpr VecPos Inner = static_cast(Index & 0x3);\n constexpr VecPos Outer = static_cast((Index & 0x4) / 4);\n return Mem::permute(Mem::permute128(d.v()));\n}\ntemplate <> template Vc_INTRINSIC AVX2::double_v AVX2::double_v::broadcast() const\n{\n constexpr VecPos Inner = static_cast(Index & 0x1);\n constexpr VecPos Outer = static_cast((Index & 0x2) / 2);\n return Mem::permute(Mem::permute128(d.v()));\n}\n// }}}1\n} // namespace Vc\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/avx/vectorhelper.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_AVX_VECTORHELPER_H_\n#define VC_AVX_VECTORHELPER_H_\n\n#include \n#include \"types.h\"\n#include \"intrinsics.h\"\n#include \"casts.h\"\n#include \"../common/loadstoreflags.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace AVX\n{\n template<> struct VectorHelper<__m256>\n {\n typedef __m256 VectorType;\n typedef const VectorType VTArg;\n\n template static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, typename Flags::EnableIfAligned = nullptr) { _mm256_store_ps(mem, x); }\n template static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { _mm256_storeu_ps(mem, x); }\n template static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, typename Flags::EnableIfStreaming = nullptr) { _mm256_stream_ps(mem, x); }\n template static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { AvxIntrinsics::stream_store(mem, x, setallone_ps()); }\n\n template static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, VTArg m, typename std::enable_if::type = nullptr) { _mm256_maskstore(mem, m, x); }\n template static Vc_ALWAYS_INLINE void store(float *mem, VTArg x, VTArg m, typename std::enable_if< Flags::IsStreaming, void *>::type = nullptr) { AvxIntrinsics::stream_store(mem, x, m); }\n };\n\n template<> struct VectorHelper<__m256d>\n {\n typedef __m256d VectorType;\n typedef const VectorType VTArg;\n\n template static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, typename Flags::EnableIfAligned = nullptr) { _mm256_store_pd(mem, x); }\n template static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { _mm256_storeu_pd(mem, x); }\n template static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, typename Flags::EnableIfStreaming = nullptr) { _mm256_stream_pd(mem, x); }\n template static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { AvxIntrinsics::stream_store(mem, x, setallone_pd()); }\n\n template static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, VTArg m, typename std::enable_if::type = nullptr) { _mm256_maskstore(mem, m, x); }\n template static Vc_ALWAYS_INLINE void store(double *mem, VTArg x, VTArg m, typename std::enable_if< Flags::IsStreaming, void *>::type = nullptr) { AvxIntrinsics::stream_store(mem, x, m); }\n };\n\n template<> struct VectorHelper<__m256i>\n {\n typedef __m256i VectorType;\n typedef const VectorType VTArg;\n\n template static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, typename Flags::EnableIfAligned = nullptr) { _mm256_store_si256(reinterpret_cast<__m256i *>(mem), x); }\n template static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, typename Flags::EnableIfUnalignedNotStreaming = nullptr) { _mm256_storeu_si256(reinterpret_cast<__m256i *>(mem), x); }\n template static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, typename Flags::EnableIfStreaming = nullptr) { _mm256_stream_si256(reinterpret_cast<__m256i *>(mem), x); }\n template static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, typename Flags::EnableIfUnalignedAndStreaming = nullptr) { AvxIntrinsics::stream_store(mem, x, setallone_si256()); }\n\n template static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, VTArg m, typename std::enable_if::type = nullptr) { _mm256_maskstore(mem, m, x); }\n template static Vc_ALWAYS_INLINE void store(T *mem, VTArg x, VTArg m, typename std::enable_if< Flags::IsStreaming, void *>::type = nullptr) { AvxIntrinsics::stream_store(mem, x, m); }\n };\n\n#define Vc_OP1(op) \\\n static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a) { return Vc_CAT2(_mm256_##op##_, Vc_SUFFIX)(a); }\n#define Vc_OP(op) \\\n static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return Vc_CAT2(op##_ , Vc_SUFFIX)(a, b); }\n#define Vc_OP_(op) \\\n static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return Vc_CAT2(_mm256_##op , Vc_SUFFIX)(a, b); }\n#define Vc_OPx(op, op2) \\\n static Vc_INTRINSIC VectorType Vc_CONST op(VTArg a, VTArg b) { return Vc_CAT2(_mm256_##op2##_, Vc_SUFFIX)(a, b); }\n\n template<> struct VectorHelper {\n typedef __m256d VectorType;\n typedef const VectorType VTArg;\n typedef double EntryType;\n#define Vc_SUFFIX pd\n\n static Vc_ALWAYS_INLINE VectorType notMaskedToZero(VTArg a, __m256 mask) { return Vc_CAT2(_mm256_and_, Vc_SUFFIX)(_mm256_castps_pd(mask), a); }\n static Vc_ALWAYS_INLINE VectorType set(const double a) { return Vc_CAT2(_mm256_set1_, Vc_SUFFIX)(a); }\n static Vc_ALWAYS_INLINE VectorType set(const double a, const double b, const double c, const double d) {\n return Vc_CAT2(_mm256_set_, Vc_SUFFIX)(a, b, c, d);\n }\n static Vc_ALWAYS_INLINE VectorType zero() { return Vc_CAT2(_mm256_setzero_, Vc_SUFFIX)(); }\n static Vc_ALWAYS_INLINE VectorType one() { return Vc_CAT2(setone_, Vc_SUFFIX)(); }// set(1.); }\n\n static inline void fma(VectorType &v1, VTArg v2, VTArg v3) {\n#ifdef Vc_IMPL_FMA4\n v1 = _mm256_macc_pd(v1, v2, v3);\n#else\n VectorType h1 = _mm256_and_pd(v1, _mm256_broadcast_sd(reinterpret_cast(&c_general::highMaskDouble)));\n VectorType h2 = _mm256_and_pd(v2, _mm256_broadcast_sd(reinterpret_cast(&c_general::highMaskDouble)));\n#if defined(Vc_GCC) && Vc_GCC < 0x40703\n // GCC before 4.7.3 uses an incorrect optimization where it replaces the subtraction with an andnot\n // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=54703\n asm(\"\":\"+x\"(h1), \"+x\"(h2));\n#endif\n const VectorType l1 = _mm256_sub_pd(v1, h1);\n const VectorType l2 = _mm256_sub_pd(v2, h2);\n const VectorType ll = mul(l1, l2);\n const VectorType lh = add(mul(l1, h2), mul(h1, l2));\n const VectorType hh = mul(h1, h2);\n // ll < lh < hh for all entries is certain\n const VectorType lh_lt_v3 = cmplt_pd(abs(lh), abs(v3)); // |lh| < |v3|\n const VectorType b = _mm256_blendv_pd(v3, lh, lh_lt_v3);\n const VectorType c = _mm256_blendv_pd(lh, v3, lh_lt_v3);\n v1 = add(add(ll, b), add(c, hh));\n#endif\n }\n\n static Vc_INTRINSIC VectorType Vc_CONST add(VTArg a, VTArg b) { return _mm256_add_pd(a,b); }\n static Vc_INTRINSIC VectorType Vc_CONST sub(VTArg a, VTArg b) { return _mm256_sub_pd(a,b); }\n static Vc_INTRINSIC VectorType Vc_CONST mul(VTArg a, VTArg b) { return _mm256_mul_pd(a,b); }\n\n Vc_OP1(sqrt)\n static Vc_ALWAYS_INLINE Vc_CONST VectorType rsqrt(VTArg x) {\n return _mm256_div_pd(one(), sqrt(x));\n }\n static Vc_ALWAYS_INLINE Vc_CONST VectorType reciprocal(VTArg x) {\n return _mm256_div_pd(one(), x);\n }\n static Vc_ALWAYS_INLINE Vc_CONST VectorType abs(VTArg a) {\n return Vc_CAT2(_mm256_and_, Vc_SUFFIX)(a, setabsmask_pd());\n }\n\n static Vc_INTRINSIC VectorType Vc_CONST min(VTArg a, VTArg b) { return _mm256_min_pd(a, b); }\n static Vc_INTRINSIC VectorType Vc_CONST max(VTArg a, VTArg b) { return _mm256_max_pd(a, b); }\n static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VTArg a) {\n __m128d b = _mm_min_pd(avx_cast<__m128d>(a), _mm256_extractf128_pd(a, 1));\n b = _mm_min_sd(b, _mm_unpackhi_pd(b, b));\n return _mm_cvtsd_f64(b);\n }\n static Vc_ALWAYS_INLINE Vc_CONST EntryType max(VTArg a) {\n __m128d b = _mm_max_pd(avx_cast<__m128d>(a), _mm256_extractf128_pd(a, 1));\n b = _mm_max_sd(b, _mm_unpackhi_pd(b, b));\n return _mm_cvtsd_f64(b);\n }\n static Vc_ALWAYS_INLINE Vc_CONST EntryType mul(VTArg a) {\n __m128d b = _mm_mul_pd(avx_cast<__m128d>(a), _mm256_extractf128_pd(a, 1));\n b = _mm_mul_sd(b, _mm_shuffle_pd(b, b, _MM_SHUFFLE2(0, 1)));\n return _mm_cvtsd_f64(b);\n }\n static Vc_ALWAYS_INLINE Vc_CONST EntryType add(VTArg a) {\n __m128d b = _mm_add_pd(avx_cast<__m128d>(a), _mm256_extractf128_pd(a, 1));\n b = _mm_hadd_pd(b, b); // or: b = _mm_add_sd(b, _mm256_shuffle_pd(b, b, _MM_SHUFFLE2(0, 1)));\n return _mm_cvtsd_f64(b);\n }\n#undef Vc_SUFFIX\n static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VTArg a) {\n return _mm256_round_pd(a, _MM_FROUND_NINT);\n }\n };\n\n template<> struct VectorHelper {\n typedef float EntryType;\n typedef __m256 VectorType;\n typedef const VectorType VTArg;\n#define Vc_SUFFIX ps\n\n static Vc_ALWAYS_INLINE Vc_CONST VectorType notMaskedToZero(VTArg a, __m256 mask) { return Vc_CAT2(_mm256_and_, Vc_SUFFIX)(mask, a); }\n static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a) { return Vc_CAT2(_mm256_set1_, Vc_SUFFIX)(a); }\n static Vc_ALWAYS_INLINE Vc_CONST VectorType set(const float a, const float b, const float c, const float d,\n const float e, const float f, const float g, const float h) {\n return Vc_CAT2(_mm256_set_, Vc_SUFFIX)(a, b, c, d, e, f, g, h); }\n static Vc_ALWAYS_INLINE Vc_CONST VectorType zero() { return Vc_CAT2(_mm256_setzero_, Vc_SUFFIX)(); }\n static Vc_ALWAYS_INLINE Vc_CONST VectorType one() { return Vc_CAT2(setone_, Vc_SUFFIX)(); }// set(1.f); }\n static Vc_ALWAYS_INLINE Vc_CONST __m256 concat(__m256d a, __m256d b) { return _mm256_insertf128_ps(avx_cast<__m256>(_mm256_cvtpd_ps(a)), _mm256_cvtpd_ps(b), 1); }\n\n static inline void fma(VectorType &v1, VTArg v2, VTArg v3) {\n#ifdef Vc_IMPL_FMA4\n v1 = _mm256_macc_ps(v1, v2, v3);\n#else\n __m256d v1_0 = _mm256_cvtps_pd(lo128(v1));\n __m256d v1_1 = _mm256_cvtps_pd(hi128(v1));\n __m256d v2_0 = _mm256_cvtps_pd(lo128(v2));\n __m256d v2_1 = _mm256_cvtps_pd(hi128(v2));\n __m256d v3_0 = _mm256_cvtps_pd(lo128(v3));\n __m256d v3_1 = _mm256_cvtps_pd(hi128(v3));\n v1 = AVX::concat(\n _mm256_cvtpd_ps(_mm256_add_pd(_mm256_mul_pd(v1_0, v2_0), v3_0)),\n _mm256_cvtpd_ps(_mm256_add_pd(_mm256_mul_pd(v1_1, v2_1), v3_1)));\n#endif\n }\n\n static Vc_INTRINSIC VectorType Vc_CONST add(VTArg a, VTArg b) { return _mm256_add_ps(a, b); }\n static Vc_INTRINSIC VectorType Vc_CONST sub(VTArg a, VTArg b) { return _mm256_sub_ps(a, b); }\n static Vc_INTRINSIC VectorType Vc_CONST mul(VTArg a, VTArg b) { return _mm256_mul_ps(a, b); }\n\n Vc_OP1(sqrt) Vc_OP1(rsqrt)\n static Vc_ALWAYS_INLINE Vc_CONST VectorType reciprocal(VTArg x) {\n return _mm256_rcp_ps(x);\n }\n static Vc_ALWAYS_INLINE Vc_CONST VectorType abs(VTArg a) {\n return Vc_CAT2(_mm256_and_, Vc_SUFFIX)(a, setabsmask_ps());\n }\n\n static Vc_INTRINSIC VectorType Vc_CONST min(VTArg a, VTArg b) { return _mm256_min_ps(a, b); }\n static Vc_INTRINSIC VectorType Vc_CONST max(VTArg a, VTArg b) { return _mm256_max_ps(a, b); }\n static Vc_ALWAYS_INLINE Vc_CONST EntryType min(VTArg a) {\n __m128 b = _mm_min_ps(lo128(a), hi128(a));\n b = _mm_min_ps(b, _mm_movehl_ps(b, b)); // b = min(a0, a2), min(a1, a3), min(a2, a2), min(a3, a3)\n b = _mm_min_ss(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(1, 1, 1, 1))); // b = min(a0, a1), a1, a2, a3\n return _mm_cvtss_f32(b);\n }\n static Vc_ALWAYS_INLINE Vc_CONST EntryType max(VTArg a) {\n __m128 b = _mm_max_ps(avx_cast<__m128>(a), _mm256_extractf128_ps(a, 1));\n b = _mm_max_ps(b, _mm_movehl_ps(b, b)); // b = max(a0, a2), max(a1, a3), max(a2, a2), max(a3, a3)\n b = _mm_max_ss(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(1, 1, 1, 1))); // b = max(a0, a1), a1, a2, a3\n return _mm_cvtss_f32(b);\n }\n static Vc_ALWAYS_INLINE Vc_CONST EntryType mul(VTArg a) {\n __m128 b = _mm_mul_ps(avx_cast<__m128>(a), _mm256_extractf128_ps(a, 1));\n b = _mm_mul_ps(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 1, 2, 3)));\n b = _mm_mul_ss(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 2, 0, 1)));\n return _mm_cvtss_f32(b);\n }\n static Vc_ALWAYS_INLINE Vc_CONST EntryType add(VTArg a) {\n __m128 b = _mm_add_ps(avx_cast<__m128>(a), _mm256_extractf128_ps(a, 1));\n b = _mm_add_ps(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 1, 2, 3)));\n b = _mm_add_ss(b, _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 2, 0, 1)));\n return _mm_cvtss_f32(b);\n }\n#undef Vc_SUFFIX\n static Vc_ALWAYS_INLINE Vc_CONST VectorType round(VTArg a) {\n return _mm256_round_ps(a, _MM_FROUND_NINT);\n }\n };\n\n#undef Vc_OP1\n#undef Vc_OP\n#undef Vc_OP_\n#undef Vc_OPx\n\n} // namespace AVX(2)\n} // namespace Vc\n\n#endif // VC_AVX_VECTORHELPER_H_\n" }, { "path": "3rdparty/Vc/Vc/common/algorithms.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_ALGORITHMS_H_\n#define VC_COMMON_ALGORITHMS_H_\n\n#include \"simdize.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n#ifdef DOXYGEN\n/**\n * \\ingroup Utilities\n * \\headerfile algorithms.h \n *\n * Vc variant of the `std::for_each` algorithm.\n *\n * This algorithm calls \\p f with one argument of type\n * `Vc::Vector<` *iterator value type* `, ` *unspecified* `>` as often as is needed to\n * iterate over the complete range from \\p first to \\p last.\n * It will try to use the best vector size (VectorAbi) to work on the largest chunks\n * possible.\n * To support aligned loads (and stores) and to support arbitrary range distances, the\n * algorithm may require the use of `Vc::VectorAbi` types that work on fewer elements in\n * parallel.\n *\n * The following example requires C++14 for generic lambdas. If you don't have generic\n * lambdas available you can use a \"classic\" functor type with a templated call operator\n * instead.\n *\n * \\code\n * void scale(std::vector &data, double factor) {\n * Vc::simd_for_each(data.begin(), data.end(), [&](auto v) {\n * v *= factor;\n * });\n * }\n * \\endcode\n */\ntemplate \nUnaryFunction simd_for_each(InputIt first, InputIt last, UnaryFunction f);\n#else\ntemplate ::value_type>\ninline enable_if<\n Traits::is_functor_argument_immutable>::value,\n UnaryFunction>\nsimd_for_each(InputIt first, InputIt last, UnaryFunction f)\n{\n typedef simdize V;\n typedef simdize V1;\n const auto lastV = last - V::Size + 1;\n for (; first < lastV; first += V::Size) {\n V tmp;\n load_interleaved(tmp, std::addressof(*first));\n f(tmp);\n }\n for (; first != last; ++first) {\n V1 tmp;\n load_interleaved(tmp, std::addressof(*first));\n f(tmp);\n }\n return f;\n}\n\ntemplate ::value_type>\ninline enable_if<\n !Traits::is_functor_argument_immutable>::value,\n UnaryFunction>\nsimd_for_each(InputIt first, InputIt last, UnaryFunction f)\n{\n typedef simdize V;\n typedef simdize V1;\n const auto lastV = last - V::size() + 1;\n for (; first < lastV; first += V::size()) {\n V tmp;\n load_interleaved(tmp, std::addressof(*first));\n f(tmp);\n store_interleaved(tmp, std::addressof(*first));\n }\n for (; first != last; ++first) {\n V1 tmp;\n load_interleaved(tmp, std::addressof(*first));\n f(tmp);\n store_interleaved(tmp, std::addressof(*first));\n }\n return f;\n}\n#endif\n\n///////////////////////////////////////////////////////////////////////////////\ntemplate ::value_type>\ninline enable_if<\n Traits::is_functor_argument_immutable>::value,\n UnaryFunction>\nsimd_for_each_n(InputIt first, std::size_t count, UnaryFunction f)\n{\n typename std::make_signed::type len = count;\n typedef simdize V;\n typedef simdize V1;\n for (; len >= int(V::size()); len -= V::Size, first += V::Size) {\n V tmp;\n load_interleaved(tmp, std::addressof(*first));\n f(tmp);\n }\n for (; len != 0; --len, ++first) {\n V1 tmp;\n load_interleaved(tmp, std::addressof(*first));\n f(tmp);\n }\n return f;\n}\n\ntemplate ::value_type>\ninline enable_if<\n !Traits::is_functor_argument_immutable>::value,\n UnaryFunction>\nsimd_for_each_n(InputIt first, std::size_t count, UnaryFunction f)\n{\n typename std::make_signed::type len = count;\n typedef simdize V;\n typedef simdize V1;\n for (; len >= int(V::size()); len -= V::Size, first += V::Size) {\n V tmp;\n load_interleaved(tmp, std::addressof(*first));\n f(tmp);\n store_interleaved(tmp, std::addressof(*first));\n }\n for (; len != 0; --len, ++first) {\n V1 tmp;\n load_interleaved(tmp, std::addressof(*first));\n f(tmp);\n store_interleaved(tmp, std::addressof(*first));\n }\n return f;\n}\n\n} // namespace Vc\n\n#endif // VC_COMMON_ALGORITHMS_H_\n" }, { "path": "3rdparty/Vc/Vc/common/aliasingentryhelper.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2010-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_ALIASINGENTRYHELPER_H_\n#define VC_COMMON_ALIASINGENTRYHELPER_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n\ntemplate class AliasingEntryHelper\n{\n private:\n typedef typename StorageType::EntryType T;\n#ifdef Vc_ICC\n StorageType *const m_storage;\n const int m_index;\n public:\n Vc_ALWAYS_INLINE AliasingEntryHelper(StorageType *d, int index) : m_storage(d), m_index(index) {}\n Vc_ALWAYS_INLINE AliasingEntryHelper(const AliasingEntryHelper &) = default;\n Vc_ALWAYS_INLINE AliasingEntryHelper(AliasingEntryHelper &&) = default;\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator=(const AliasingEntryHelper &rhs) {\n m_storage->assign(m_index, rhs);\n return *this;\n }\n\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator =(T x) { m_storage->assign(m_index, x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator +=(T x) { m_storage->assign(m_index, m_storage->m(m_index) + x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator -=(T x) { m_storage->assign(m_index, m_storage->m(m_index) - x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator /=(T x) { m_storage->assign(m_index, m_storage->m(m_index) / x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator *=(T x) { m_storage->assign(m_index, m_storage->m(m_index) * x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator |=(T x) { m_storage->assign(m_index, m_storage->m(m_index) | x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator &=(T x) { m_storage->assign(m_index, m_storage->m(m_index) & x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator ^=(T x) { m_storage->assign(m_index, m_storage->m(m_index) ^ x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator %=(T x) { m_storage->assign(m_index, m_storage->m(m_index) % x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator<<=(T x) { m_storage->assign(m_index, m_storage->m(m_index)<< x); return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator>>=(T x) { m_storage->assign(m_index, m_storage->m(m_index)>> x); return *this; }\n#define m_data m_storage->read(m_index)\n#else\n typedef T A Vc_MAY_ALIAS;\n A &m_data;\n public:\n template\n Vc_ALWAYS_INLINE AliasingEntryHelper(T2 &d) : m_data(reinterpret_cast(d)) {}\n\n Vc_ALWAYS_INLINE AliasingEntryHelper(A &d) : m_data(d) {}\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator=(const AliasingEntryHelper &rhs) {\n m_data = rhs.m_data;\n return *this;\n }\n\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator =(T x) { m_data = x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator+=(T x) { m_data += x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator-=(T x) { m_data -= x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator/=(T x) { m_data /= x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator*=(T x) { m_data *= x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator|=(T x) { m_data |= x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator&=(T x) { m_data &= x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator^=(T x) { m_data ^= x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator%=(T x) { m_data %= x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator<<=(T x) { m_data <<= x; return *this; }\n Vc_ALWAYS_INLINE AliasingEntryHelper &operator>>=(T x) { m_data >>= x; return *this; }\n#endif\n\n Vc_ALWAYS_INLINE Vc_PURE operator const T() const { return m_data; }\n\n Vc_ALWAYS_INLINE Vc_PURE bool operator==(T x) const { return static_cast(m_data) == x; }\n Vc_ALWAYS_INLINE Vc_PURE bool operator!=(T x) const { return static_cast(m_data) != x; }\n Vc_ALWAYS_INLINE Vc_PURE bool operator<=(T x) const { return static_cast(m_data) <= x; }\n Vc_ALWAYS_INLINE Vc_PURE bool operator>=(T x) const { return static_cast(m_data) >= x; }\n Vc_ALWAYS_INLINE Vc_PURE bool operator< (T x) const { return static_cast(m_data) < x; }\n Vc_ALWAYS_INLINE Vc_PURE bool operator> (T x) const { return static_cast(m_data) > x; }\n\n Vc_ALWAYS_INLINE Vc_PURE T operator-() const { return -static_cast(m_data); }\n Vc_ALWAYS_INLINE Vc_PURE T operator~() const { return ~static_cast(m_data); }\n Vc_ALWAYS_INLINE Vc_PURE T operator+(T x) const { return static_cast(m_data) + x; }\n Vc_ALWAYS_INLINE Vc_PURE T operator-(T x) const { return static_cast(m_data) - x; }\n Vc_ALWAYS_INLINE Vc_PURE T operator/(T x) const { return static_cast(m_data) / x; }\n Vc_ALWAYS_INLINE Vc_PURE T operator*(T x) const { return static_cast(m_data) * x; }\n Vc_ALWAYS_INLINE Vc_PURE T operator|(T x) const { return static_cast(m_data) | x; }\n Vc_ALWAYS_INLINE Vc_PURE T operator&(T x) const { return static_cast(m_data) & x; }\n Vc_ALWAYS_INLINE Vc_PURE T operator^(T x) const { return static_cast(m_data) ^ x; }\n Vc_ALWAYS_INLINE Vc_PURE T operator%(T x) const { return static_cast(m_data) % x; }\n //T operator<<(T x) const { return static_cast(m_data) << x; }\n //T operator>>(T x) const { return static_cast(m_data) >> x; }\n#ifdef m_data\n#undef m_data\n#endif\n};\n\n} // namespace Common\n} // namespace Vc\n\n#endif // VC_COMMON_ALIASINGENTRYHELPER_H_\n" }, { "path": "3rdparty/Vc/Vc/common/alignedbase.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_ALIGNEDBASE_H_\n#define VC_COMMON_ALIGNEDBASE_H_\n\n#include \"types.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Detail\n{\n/**\\internal\n * Break the recursion of the function below.\n */\ntemplate constexpr T max(T a) { return a; }\n/**\\internal\n * \\returns the maximum of all specified arguments.\n */\ntemplate constexpr T max(T a, T b, Ts... rest)\n{\n return a > b ? max(a, rest...) : max(b, rest...);\n}\n} // namespace Detail\nnamespace Common\n{\ntemplate Vc_INTRINSIC void *aligned_malloc(std::size_t);\nVc_ALWAYS_INLINE void free(void *);\n} // namespace Common\n\n/**\n * \\ingroup Utilities\n *\n * Helper class to ensure a given alignment.\n *\n * This class reimplements the \\c new and \\c delete operators to align objects allocated\n * on the heap suitably with the specified alignment \\c Alignment.\n *\n * \\see Vc::VectorAlignedBase\n * \\see Vc::MemoryAlignedBase\n */\ntemplate struct alignas(Alignment) AlignedBase\n{\n Vc_FREE_STORE_OPERATORS_ALIGNED(Alignment);\n};\n\n/**\n * \\ingroup Utilities\n *\n * Helper type to ensure suitable alignment for any Vc::Vector type (using the default\n * VectorAbi).\n *\n * This class reimplements the \\c new and \\c delete operators to align objects allocated\n * on the heap suitably for objects of Vc::Vector type. This is necessary since the\n * standard \\c new operator does not adhere to the alignment requirements of the type.\n *\n * \\see Vc::VectorAlignedBaseT\n * \\see Vc::MemoryAlignedBase\n * \\see Vc::AlignedBase\n */\nusing VectorAlignedBase = AlignedBase<\n Detail::max(alignof(Vector), alignof(Vector), alignof(Vector),\n alignof(Vector), alignof(Vector), alignof(Vector),\n alignof(Vector), alignof(Vector), alignof(Vector),\n alignof(Vector), alignof(Vector), alignof(Vector))>;\n\n/**\n * \\ingroup Utilities\n * Variant of the above type ensuring suitable alignment only for the specified vector\n * type \\p V.\n *\n * \\see Vc::VectorAlignedBase\n * \\see Vc::MemoryAlignedBaseT\n */\ntemplate using VectorAlignedBaseT = AlignedBase;\n\n/**\n * \\ingroup Utilities\n *\n * Helper class to ensure suitable alignment for arrays of scalar objects for any\n * Vc::Vector type (using the default VectorAbi).\n *\n * This class reimplements the \\c new and \\c delete operators to align objects allocated\n * on the heap suitably for arrays of type \\p Vc::Vector::EntryType. Subsequent load\n * and store operations are safe to use the aligned variant.\n *\n * \\see Vc::MemoryAlignedBaseT\n * \\see Vc::VectorAlignedBase\n * \\see Vc::AlignedBase\n */\nusing MemoryAlignedBase = AlignedBase<\n Detail::max(Vector::MemoryAlignment, Vector::MemoryAlignment,\n Vector::MemoryAlignment, Vector::MemoryAlignment,\n Vector::MemoryAlignment, Vector::MemoryAlignment,\n Vector::MemoryAlignment, Vector::MemoryAlignment,\n Vector::MemoryAlignment, Vector::MemoryAlignment,\n Vector::MemoryAlignment, Vector::MemoryAlignment)>;\n\n/**\n * \\ingroup Utilities\n * Variant of the above type ensuring suitable alignment only for the specified vector\n * type \\p V.\n *\n * \\see Vc::MemoryAlignedBase\n * \\see Vc::VectorAlignedBaseT\n */\ntemplate using MemoryAlignedBaseT = AlignedBase;\n}\n\n#endif // VC_COMMON_ALIGNEDBASE_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/bitscanintrinsics.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2011-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_BITSCANINTRINSICS_H_\n#define VC_COMMON_BITSCANINTRINSICS_H_\n\n#if defined(Vc_GCC) || defined(Vc_CLANG) || defined(Vc_APPLECLANG)\n#include \n# ifndef _bit_scan_forward\n# define _bit_scan_forward(x) __builtin_ctz(x)\n#include \"macros.h\"\nstatic Vc_ALWAYS_INLINE Vc_CONST int _Vc_bit_scan_reverse_asm(unsigned int x) {\n int r;\n __asm__(\"bsr %1,%0\" : \"=r\"(r) : \"X\"(x));\n return r;\n}\n# define _bit_scan_reverse(x) _Vc_bit_scan_reverse_asm(x)\n# endif\n#elif defined(_WIN32)\n#include \nstatic inline __forceinline unsigned long _bit_scan_forward(unsigned long x) {\n\tunsigned long index;\n\t_BitScanForward(&index, x);\n\treturn index;\n}\nstatic inline __forceinline unsigned long _bit_scan_reverse(unsigned long x) {\n\tunsigned long index;\n\t_BitScanReverse(&index, x);\n\treturn index;\n}\n#elif defined(Vc_ICC)\n// for all I know ICC supports the _bit_scan_* intrinsics\n#else\n// just assume the compiler can do it\n#endif\n\n\n#endif // VC_COMMON_BITSCANINTRINSICS_H_\n" }, { "path": "3rdparty/Vc/Vc/common/const.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_CONST_H_\n#define VC_COMMON_CONST_H_\n\n#include \n#include \"../global.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Detail\n{\n\ntemplate constexpr double exponentToFloat(std::integral_constant);\ntemplate constexpr double exponentToFloat(std::integral_constant);\ntemplate <> constexpr double exponentToFloat<0>(std::integral_constant)\n{\n return 1.;\n}\ntemplate <> constexpr double exponentToFloat<0>(std::integral_constant)\n{\n return 1.;\n}\ntemplate <> constexpr double exponentToFloat<-32>(std::integral_constant)\n{\n return 1. / (65536. * 65536.);\n}\ntemplate <> constexpr double exponentToFloat<32>(std::integral_constant)\n{\n return 65536. * 65536.;\n}\ntemplate <> constexpr double exponentToFloat<-64>(std::integral_constant)\n{\n return 1. / (65536. * 65536. * 65536. * 65536.);\n}\ntemplate <> constexpr double exponentToFloat<64>(std::integral_constant)\n{\n return 65536. * 65536. * 65536. * 65536.;\n}\ntemplate \nconstexpr double exponentToFloat(std::integral_constant negative)\n{\n return exponentToFloat(negative) * 2.0;\n}\ntemplate \nconstexpr double exponentToFloat(std::integral_constant negative)\n{\n return exponentToFloat(negative) * 0.5;\n}\ntemplate constexpr double doubleConstant()\n{\n return (static_cast((mantissa & 0x000fffffffffffffull) | 0x0010000000000000ull) /\n 0x0010000000000000ull) *\n exponentToFloat(std::integral_constant()) * sign;\n}\ntemplate constexpr float floatConstant()\n{\n return (static_cast((mantissa & 0x007fffffu) | 0x00800000u) / 0x00800000u) *\n static_cast(\n exponentToFloat(std::integral_constant())) *\n sign;\n}\n\n} // namespace Detail\n} // namespace Vc\n\n#endif // VC_COMMON_CONST_H_\n" }, { "path": "3rdparty/Vc/Vc/common/data.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_CONST_DATA_H_\n#define VC_COMMON_CONST_DATA_H_\n\n#include \"macros.h\"\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n\nalignas(64) extern unsigned int RandomState[];\nalignas(32) extern const unsigned int AllBitsSet[8];\n\n} // namespace Common\n} // namespace Vc\n\n#endif // VC_COMMON_CONST_DATA_H_\n" }, { "path": "3rdparty/Vc/Vc/common/deinterleave.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2010-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_DEINTERLEAVE_H_\n#define VC_COMMON_DEINTERLEAVE_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n\n/**\n * \\ingroup Vectors\n *\n * \\deprecated Turn to InterleavedMemoryWrapper for a more flexible and complete solution.\n *\n * Loads two vectors of values from an interleaved array.\n *\n * \\param a, b The vectors to load the values from memory into.\n * \\param memory The memory location where to read the next 2 * V::Size values from\n * \\param align Either pass Vc::Aligned or Vc::Unaligned. It defaults to Vc::Aligned if nothing is\n * specified.\n *\n * If you store your data as\n * \\code\n * struct { float x, y; } m[1000];\n * \\endcode\n * then the deinterleave function allows you to read \\p Size concurrent x and y values like this:\n * \\code\n * Vc::float_v x, y;\n * Vc::deinterleave(&x, &y, &m[10], Vc::Unaligned);\n * \\endcode\n * This code will load m[10], m[12], m[14], ... into \\p x and m[11], m[13], m[15], ... into \\p y.\n *\n * The deinterleave function supports the following type combinations:\n\\verbatim\n V \\ M | float | double | ushort | short | uint | int\n=========|=======|========|========|=======|======|=====\n float_v | X | | X | X | |\n---------|-------|--------|--------|-------|------|-----\ndouble_v | | X | | | |\n---------|-------|--------|--------|-------|------|-----\n int_v | | | | X | | X\n---------|-------|--------|--------|-------|------|-----\n uint_v | | | X | | X |\n---------|-------|--------|--------|-------|------|-----\n short_v | | | | X | |\n---------|-------|--------|--------|-------|------|-----\nushort_v | | | X | | |\n\\endverbatim\n */\ntemplate Vc_ALWAYS_INLINE void deinterleave(V *a, V *b,\n const M *memory, A align)\n{\n Detail::deinterleave(*a, *b, memory, align);\n}\n\n// documented as default for align above\ntemplate Vc_ALWAYS_INLINE void deinterleave(V *a, V *b,\n const M *memory)\n{\n Detail::deinterleave(*a, *b, memory, Aligned);\n}\n\n} // namespace Vc\n\n#endif // VC_COMMON_DEINTERLEAVE_H_\n" }, { "path": "3rdparty/Vc/Vc/common/detail.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2018 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_DETAIL_H_\n#define VC_COMMON_DETAIL_H_\n\n#include \n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n// convertIndexVector {{{\n// if the argument is a Vector already we definitely want to keep it that way\ntemplate \nVc_INTRINSIC enable_if<(Traits::is_simd_vector::value &&\n sizeof(typename IV::EntryType) >= sizeof(int)),\n const IV &>\nconvertIndexVector(const IV &indexVector)\n{\n return indexVector;\n}\n\n// but if the scalar (integral) type is smaller than int we convert it up to int. Otherwise it's\n// very likely that the calculations we have to perform will overflow.\ntemplate \nVc_INTRINSIC enable_if<(Traits::is_simd_vector::value &&\n sizeof(typename IV::EntryType) < sizeof(int)),\n fixed_size_simd>\nconvertIndexVector(const IV &indexVector)\n{\n return static_cast>(indexVector);\n}\n\n// helper for promoting int types to int or higher\ntemplate using promoted_type = decltype(std::declval() + 1);\n\n// std::array, Vc::array, and C-array are fixed size and can therefore be converted to a\n// fixed_size_simd of the same size\ntemplate \nVc_INTRINSIC enable_if::value, fixed_size_simd, N>>\nconvertIndexVector(const std::array &indexVector)\n{\n return fixed_size_simd, N>{std::addressof(indexVector[0]),\n Vc::Unaligned};\n}\ntemplate \nVc_INTRINSIC enable_if::value, fixed_size_simd, N>>\nconvertIndexVector(const Vc::array &indexVector)\n{\n return fixed_size_simd, N>{std::addressof(indexVector[0]),\n Vc::Unaligned};\n}\ntemplate \nVc_INTRINSIC enable_if::value, fixed_size_simd, N>>\nconvertIndexVector(const T (&indexVector)[N])\n{\n return fixed_size_simd, N>{std::addressof(indexVector[0]),\n Vc::Unaligned};\n}\n\n// a plain pointer won't work. Because we need some information on the number of values in\n// the index argument\n#ifndef Vc_MSVC\n// MSVC treats the function as usable in SFINAE context if it is deleted. If it's not declared we\n// seem to get what we wanted (except for bad diagnostics)\ntemplate \nenable_if::value, void> convertIndexVector(T indexVector) = delete;\n#endif\n\n// an initializer_list works, but is runtime-sized (before C++14, at least) so we have to\n// fall back to std::vector\ntemplate \nVc_INTRINSIC std::vector> convertIndexVector(\n const std::initializer_list &indexVector)\n{\n return {begin(indexVector), end(indexVector)};\n}\n\n// a std::vector cannot be converted to anything better\ntemplate \nVc_INTRINSIC\n enable_if<(std::is_integral::value && sizeof(T) >= sizeof(int)), std::vector>\n convertIndexVector(const std::vector &indexVector)\n{\n return indexVector;\n}\ntemplate \nVc_INTRINSIC enable_if<(std::is_integral::value && sizeof(T) < sizeof(int)),\n std::vector>>\nconvertIndexVector(const std::vector &indexVector)\n{\n return {std::begin(indexVector), std::end(indexVector)};\n}\n\ntemplate ::value && !Traits::is_simd_vector::value &&\n !std::is_lvalue_reference()[0])>::value)>>\nVc_INTRINSIC const T &convertIndexVector(const T &i)\n{\n return i;\n}\n\n// }}}\n} // namespace Common\n} // namespace Vc_VERSIONED_NAMESPACE\n\n#endif // VC_COMMON_DETAIL_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/elementreference.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2016 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_ELEMENTREFERENCE_H_\n#define VC_COMMON_ELEMENTREFERENCE_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Detail\n{\ntemplate class ElementReference\n{\n friend U;\n friend Accessor;\n Vc_INTRINSIC ElementReference(U &o, int i) noexcept : index(i), obj(o) {}\n\n static constexpr bool get_noexcept =\n noexcept(Accessor::get(std::declval(), int()));\n template static constexpr bool set_noexcept()\n {\n return noexcept(Accessor::set(std::declval(), int(), std::declval()));\n }\n\npublic:\n using value_type = typename U::value_type;\n Vc_INTRINSIC ElementReference(const ElementReference &) = delete;\n\n /**\n * Move Constructor\n *\n * this is the only way to constructor an ElementReference in user code\n *\n * \\note\n * Please be aware that this class models the concept of a reference\n * and as such it can have the same lifetime issue as a standard C++\n * reference.\n *\n * \\note\n * C++ 17 support copy-elision, which in turn allows to\n * the ElementReference obtained via operator[] from a function\n * and avoid copying. C++11 and C++14 don't offer this, thus we add\n * the move constructor, to allow them to move the data and thus avoid\n * copying (which was prohibited by the deleted constructor above\n */\n Vc_INTRINSIC ElementReference(ElementReference &&) = default;\n\n Vc_INTRINSIC operator value_type() const noexcept(get_noexcept)\n {\n return Accessor::get(obj, index);\n }\n\n template \n Vc_INTRINSIC ElementReference &operator=(T &&x) &&\n noexcept(noexcept(Accessor::set(std::declval(), int(), std::declval())))\n {\n Accessor::set(obj, index, std::forward(x));\n return *this;\n }\n\n// TODO: improve with operator.()\n\n#define Vc_OP_(op_) \\\n template () \\\n op_ std::declval())> \\\n Vc_INTRINSIC ElementReference &operator op_##=(T &&x) && \\\n noexcept(get_noexcept && noexcept(Accessor::set(std::declval(), int(), \\\n std::declval()))) \\\n { \\\n const value_type &lhs = Accessor::get(obj, index); \\\n Accessor::set(obj, index, lhs op_ std::forward(x)); \\\n return *this; \\\n }\n Vc_ALL_ARITHMETICS(Vc_OP_);\n Vc_ALL_SHIFTS(Vc_OP_);\n Vc_ALL_BINARY(Vc_OP_);\n#undef Vc_OP_\n\n template \n Vc_INTRINSIC ElementReference &operator++() &&\n noexcept(noexcept(std::declval() =\n Accessor::get(std::declval(), int())) &&\n set_noexcept())>())\n {\n value_type x = Accessor::get(obj, index);\n Accessor::set(obj, index, ++x);\n return *this;\n }\n\n template \n Vc_INTRINSIC value_type operator++(int) &&\n noexcept(noexcept(std::declval() =\n Accessor::get(std::declval(), int())) &&\n set_noexcept()++)>())\n {\n const value_type r = Accessor::get(obj, index);\n value_type x = r;\n Accessor::set(obj, index, ++x);\n return r;\n }\n\n template \n Vc_INTRINSIC ElementReference &operator--() &&\n noexcept(noexcept(std::declval() =\n Accessor::get(std::declval(), int())) &&\n set_noexcept())>())\n {\n value_type x = Accessor::get(obj, index);\n Accessor::set(obj, index, --x);\n return *this;\n }\n\n template \n Vc_INTRINSIC value_type operator--(int) &&\n noexcept(noexcept(std::declval() =\n Accessor::get(std::declval(), int())) &&\n set_noexcept()--)>())\n {\n const value_type r = Accessor::get(obj, index);\n value_type x = r;\n Accessor::set(obj, index, --x);\n return r;\n }\n\n friend void swap(ElementReference &&a, ElementReference &&b) {\n value_type tmp(a);\n static_cast(a) = static_cast(b);\n static_cast(b) = tmp;\n }\n\n friend void swap(value_type &a, ElementReference &&b) {\n value_type tmp(a);\n a = static_cast(b);\n static_cast(b) = tmp;\n }\n\n friend void swap(ElementReference &&a, value_type &b) {\n value_type tmp(a);\n static_cast(a) = b;\n b = tmp;\n }\n\nprivate:\n int index;\n U &obj;\n};\n\n} // namespace Detail\n} // namespace Vc\n\n#endif // VC_COMMON_ELEMENTREFERENCE_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/exponential.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2012-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n-------------------------------------------------------------------\n\nThe exp implementation is derived from Cephes, which carries the\nfollowing Copyright notice:\n\nCephes Math Library Release 2.2: June, 1992\nCopyright 1984, 1987, 1989 by Stephen L. Moshier\nDirect inquiries to 30 Frost Street, Cambridge, MA 02140\n\n}}}*/\n\n#ifdef Vc_COMMON_MATH_H_INTERNAL\n\nconstexpr float log2_e = 1.44269504088896341f;\n\n// These constants are adjusted to account for single-precision floating point.\n// The original are for double precision:\n// \n// constexpr float MAXLOGF = 88.72283905206835f;\n// constexpr float MINLOGF = -103.278929903431851103f; /* log(2^-149) */\n\nconstexpr float MAXLOGF = 88.722831726074219f; /* log(2^127.99998474121094f) */\nconstexpr float MINLOGF = -88.029685974121094f; /* log(2^-126.99999237060547f) */\nconstexpr float MAXNUMF = 3.4028234663852885981170418348451692544e38f;\n\ntemplate ::value ||\n std::is_same::value>>\ninline Vector> exp(Vector x)\n{\n using V = Vector;\n typedef typename V::Mask M;\n typedef Detail::Const C;\n\n const M overflow = x > MAXLOGF;\n const M underflow = x < MINLOGF;\n\n // log₂(eˣ) = x * log₂(e) * log₂(2)\n // = log₂(2^(x * log₂(e)))\n // => eˣ = 2^(x * log₂(e))\n // => n = ⌊x * log₂(e) + ½⌋\n // => y = x - n * ln(2) | recall that: ln(2) * log₂(e) == 1\n // <=> eˣ = 2ⁿ * eʸ\n V z = floor(C::log2_e() * x + 0.5f);\n const auto n = static_cast>(z);\n x -= z * C::ln2_large();\n x -= z * C::ln2_small();\n\n /* Theoretical peak relative error in [-0.5, +0.5] is 4.2e-9. */\n z = ((((( 1.9875691500E-4f * x\n + 1.3981999507E-3f) * x\n + 8.3334519073E-3f) * x\n + 4.1665795894E-2f) * x\n + 1.6666665459E-1f) * x\n + 5.0000001201E-1f) * (x * x)\n + x\n + 1.0f;\n\n x = ldexp(z, n); // == z * 2ⁿ\n\n x(overflow) = std::numeric_limits::infinity();\n x.setZero(underflow);\n\n return x;\n }\n\n#endif // Vc_COMMON_MATH_H_INTERNAL\n" }, { "path": "3rdparty/Vc/Vc/common/fix_clang_emmintrin.h", "content": "/*{{{\n Copyright (C) 2013-2015 Matthias Kretz \n\n Permission to use, copy, modify, and distribute this software\n and its documentation for any purpose and without fee is hereby\n granted, provided that the above copyright notice appear in all\n copies and that both that the copyright notice and this\n permission notice and warranty disclaimer appear in supporting\n documentation, and that the name of the author not be used in\n advertising or publicity pertaining to distribution of the\n software without specific, written prior permission.\n\n The author disclaim all warranties with regard to this\n software, including all implied warranties of merchantability\n and fitness. In no event shall the author be liable for any\n special, indirect or consequential damages or any damages\n whatsoever resulting from loss of use, data or profits, whether\n in an action of contract, negligence or other tortious action,\n arising out of or in connection with the use or performance of\n this software.\n\n}}}*/\n\n#ifndef VC_COMMON_FIX_CLANG_EMMINTRIN_H_\n#define VC_COMMON_FIX_CLANG_EMMINTRIN_H_\n\n#include \"../global.h\"\n\n#if (defined Vc_CLANG && Vc_CLANG < 0x30700) || (defined Vc_APPLECLANG && Vc_APPLECLANG < 0x70000)\n\n#ifdef _mm_slli_si128\n#undef _mm_slli_si128\n#define _mm_slli_si128(a, count) __extension__ ({ \\\n (__m128i)__builtin_ia32_pslldqi128((__m128i)(a), (count)*8); })\n#endif\n\n#ifdef _mm_srli_si128\n#undef _mm_srli_si128\n#define _mm_srli_si128(a, count) __extension__ ({ \\\n (__m128i)__builtin_ia32_psrldqi128((__m128i)(a), (count)*8); })\n#endif\n\n#ifdef _mm_shuffle_epi32\n#undef _mm_shuffle_epi32\n#define _mm_shuffle_epi32(a, imm) __extension__ ({ \\\n (__m128i)__builtin_shufflevector((__v4si)(__m128i)(a), (__v4si) _mm_set1_epi32(0), \\\n (imm) & 0x3, ((imm) & 0xc) >> 2, \\\n ((imm) & 0x30) >> 4, ((imm) & 0xc0) >> 6); })\n#endif\n\n#ifdef _mm_shufflelo_epi16\n#undef _mm_shufflelo_epi16\n#define _mm_shufflelo_epi16(a, imm) __extension__ ({ \\\n (__m128i)__builtin_shufflevector((__v8hi)(__m128i)(a), (__v8hi) _mm_set1_epi16(0), \\\n (imm) & 0x3, ((imm) & 0xc) >> 2, \\\n ((imm) & 0x30) >> 4, ((imm) & 0xc0) >> 6, \\\n 4, 5, 6, 7); })\n#endif\n\n#ifdef _mm_shufflehi_epi16\n#undef _mm_shufflehi_epi16\n#define _mm_shufflehi_epi16(a, imm) __extension__ ({ \\\n (__m128i)__builtin_shufflevector((__v8hi)(__m128i)(a), (__v8hi) _mm_set1_epi16(0), \\\n 0, 1, 2, 3, \\\n 4 + (((imm) & 0x03) >> 0), \\\n 4 + (((imm) & 0x0c) >> 2), \\\n 4 + (((imm) & 0x30) >> 4), \\\n 4 + (((imm) & 0xc0) >> 6)); })\n#endif\n\n#ifdef _mm_shuffle_pd\n#undef _mm_shuffle_pd\n#define _mm_shuffle_pd(a, b, i) __extension__ ({ \\\n __builtin_shufflevector((__m128d)(a), (__m128d)(b), (i) & 1, (((i) & 2) >> 1) + 2); })\n#endif\n\n#endif // Vc_CLANG || Vc_APPLECLANG\n\n#endif // VC_COMMON_FIX_CLANG_EMMINTRIN_H_\n" }, { "path": "3rdparty/Vc/Vc/common/gatherimplementation.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_GATHERIMPLEMENTATION_H_\n#define VC_COMMON_GATHERIMPLEMENTATION_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n\nenum class GatherScatterImplementation : int {\n SimpleLoop,\n SetIndexZero,\n BitScanLoop,\n PopcntSwitch\n};\n\nusing SimpleLoopT = std::integral_constant;\nusing SetIndexZeroT = std::integral_constant;\nusing BitScanLoopT = std::integral_constant;\nusing PopcntSwitchT = std::integral_constant;\n\ntemplate \nVc_ALWAYS_INLINE void executeGather(SetIndexZeroT,\n V &v,\n const MT *mem,\n IT &&indexes_,\n typename V::MaskArgument mask)\n{\n auto indexes = std::forward(indexes_);\n indexes.setZeroInverted(static_cast(mask));\n const V tmp(mem, indexes);\n where(mask) | v = tmp;\n}\n\ntemplate \nVc_ALWAYS_INLINE void executeGather(SimpleLoopT, V &v, const MT *mem, const IT &indexes,\n const typename V::MaskArgument mask)\n{\n if (Vc_IS_UNLIKELY(mask.isEmpty())) {\n return;\n }\n#if defined Vc_GCC && Vc_GCC >= 0x40900\n // GCC 4.8 doesn't support dependent type and constexpr vector_size argument\n constexpr std::size_t Sizeof = sizeof(V);\n using Builtin [[gnu::vector_size(Sizeof)]] = typename V::value_type;\n Builtin tmp = reinterpret_cast(v.data());\n Common::unrolled_loop([&](std::size_t i) {\n if (mask[i]) {\n tmp[i] = mem[indexes[i]];\n }\n });\n v.data() = reinterpret_cast(tmp);\n#else\n Common::unrolled_loop([&](std::size_t i) {\n if (mask[i])\n v[i] = mem[indexes[i]];\n });\n#endif\n}\n\ntemplate \nVc_ALWAYS_INLINE void executeGather(BitScanLoopT,\n V &v,\n const MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask)\n{\n#ifdef Vc_GNU_ASM\n size_t bits = mask.toInt();\n while (Vc_IS_LIKELY(bits > 0)) {\n size_t i, j;\n asm(\"bsf %[bits],%[i]\\n\\t\"\n \"bsr %[bits],%[j]\\n\\t\"\n \"btr %[i],%[bits]\\n\\t\"\n \"btr %[j],%[bits]\\n\\t\"\n : [i] \"=r\"(i), [j] \"=r\"(j), [bits] \"+r\"(bits));\n v[i] = mem[indexes[i]];\n v[j] = mem[indexes[j]];\n }\n#else\n // Alternative from Vc::SSE (0.7)\n int bits = mask.toInt();\n while (bits) {\n const int i = _bit_scan_forward(bits);\n\tbits &= bits - 1;\n\tv[i] = mem[indexes[i]];\n }\n#endif // Vc_GNU_ASM\n}\n\ntemplate \nVc_ALWAYS_INLINE void executeGather(PopcntSwitchT,\n V &v,\n const MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask,\n enable_if = nullarg)\n{\n unsigned int bits = mask.toInt();\n unsigned int low, high = 0;\n switch (Vc::Detail::popcnt16(bits)) {\n case 16:\n v.gather(mem, indexes);\n break;\n case 15:\n low = _bit_scan_forward(bits);\n bits ^= 1 << low;\n v[low] = mem[indexes[low]];\n // fallthrough\n case 14:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n high = (1 << high);\n // fallthrough\n case 13:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 12:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n high = (1 << high);\n // fallthrough\n case 11:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 10:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n high = (1 << high);\n // fallthrough\n case 9:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 8:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n high = (1 << high);\n // fallthrough\n case 7:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 6:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n high = (1 << high);\n // fallthrough\n case 5:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 4:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n high = (1 << high);\n // fallthrough\n case 3:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 2:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n // fallthrough\n case 1:\n low = _bit_scan_forward(bits);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 0:\n break;\n }\n}\ntemplate \nVc_ALWAYS_INLINE void executeGather(PopcntSwitchT,\n V &v,\n const MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask,\n enable_if = nullarg)\n{\n unsigned int bits = mask.toInt();\n unsigned int low, high = 0;\n switch (Vc::Detail::popcnt8(bits)) {\n case 8:\n v.gather(mem, indexes);\n break;\n case 7:\n low = _bit_scan_forward(bits);\n bits ^= 1 << low;\n v[low] = mem[indexes[low]];\n // fallthrough\n case 6:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n high = (1 << high);\n // fallthrough\n case 5:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 4:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n high = (1 << high);\n // fallthrough\n case 3:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 2:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n // fallthrough\n case 1:\n low = _bit_scan_forward(bits);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 0:\n break;\n }\n}\ntemplate \nVc_ALWAYS_INLINE void executeGather(PopcntSwitchT,\n V &v,\n const MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask,\n enable_if = nullarg)\n{\n unsigned int bits = mask.toInt();\n unsigned int low, high = 0;\n switch (Vc::Detail::popcnt4(bits)) {\n case 4:\n v.gather(mem, indexes);\n break;\n case 3:\n low = _bit_scan_forward(bits);\n bits ^= 1 << low;\n v[low] = mem[indexes[low]];\n // fallthrough\n case 2:\n high = _bit_scan_reverse(bits);\n v[high] = mem[indexes[high]];\n // fallthrough\n case 1:\n low = _bit_scan_forward(bits);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 0:\n break;\n }\n}\ntemplate \nVc_ALWAYS_INLINE void executeGather(PopcntSwitchT,\n V &v,\n const MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask,\n enable_if = nullarg)\n{\n unsigned int bits = mask.toInt();\n unsigned int low;\n switch (Vc::Detail::popcnt4(bits)) {\n case 2:\n v.gather(mem, indexes);\n break;\n case 1:\n low = _bit_scan_forward(bits);\n v[low] = mem[indexes[low]];\n // fallthrough\n case 0:\n break;\n }\n}\n\n} // namespace Common\n} // namespace Vc\n\n#endif // VC_COMMON_GATHERIMPLEMENTATION_H_\n" }, { "path": "3rdparty/Vc/Vc/common/gatherinterface.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef Vc_CURRENT_CLASS_NAME\n#error \"incorrect use of common/gatherinterface.h: Vc_CURRENT_CLASS_NAME must be defined to the current class name for declaring constructors.\"\n#endif\n\n///////////////////////////////////////////////////////////////////////////////////////////\n// gathers\n// A gather takes the following arguments:\n// 1. A const pointer to memory of any type that can convert to EntryType\n// 2. An indexes “vector”. The requirement is that the type implements the subscript operator,\n// stores «Size» valid index values, and each offset to the pointer above yields a valid\n// memory location for reading.\n// 3. Optionally the third argument may be a mask. The mask disables several memory reads and\n// thus removes the requirements in (2.) for the disabled entries.\n\nprivate:\n /**\\internal\n * This function implements a gather given a pointer to memory \\p mem and some\n * container object storing the gather \\p indexes.\n *\n * \\param mem This pointer must be aligned correctly for the type \\p MT. This is the\n * natural behavior of C++, so this is typically the case.\n * \\param indexes This object contains at least \\VSize{T} indexes that denote the\n * offset in \\p mem where the components for the current vector should be copied from.\n * The offset is not in Bytes, but in multiples of `sizeof(MT)`.\n */\n // enable_if::value &&\n // has_subscript_operator::value>\n template \n inline void gatherImplementation(const Common::GatherArguments &);\n\n /**\\internal\n * This overload of the above function adds a \\p mask argument to disable memory\n * accesses at the \\p indexes offsets where \\p mask is \\c false.\n */\n template \n inline void gatherImplementation(const Common::GatherArguments &,\n MaskArgument mask);\n\npublic:\n#define Vc_ASSERT_GATHER_PARAMETER_TYPES_ \\\n static_assert( \\\n std::is_convertible::value, \\\n \"The memory pointer needs to point to a type that can be converted to the \" \\\n \"EntryType of this SIMD vector type.\"); \\\n static_assert( \\\n Vc::Traits::has_subscript_operator::value, \\\n \"The indexes argument must be a type that implements the subscript operator.\"); \\\n static_assert( \\\n !Traits::is_simd_vector::value || \\\n Traits::simd_vector_size::value >= Size, \\\n \"If you use a SIMD vector for the indexes parameter, the index vector must \" \\\n \"have at least as many entries as this SIMD vector.\"); \\\n static_assert( \\\n !std::is_array::value || \\\n (std::rank::value == 1 && \\\n (std::extent::value == 0 || std::extent::value >= Size)), \\\n \"If you use a simple array for the indexes parameter, the array must have \" \\\n \"at least as many entries as this SIMD vector.\")\n\n /**\n * \\name Gather constructors and member functions\n *\n * Constructs or loads a vector from the objects at `mem[indexes[0]]`,\n * `mem[indexes[1]]`, `mem[indexes[2]]`, ...\n *\n * All gather functions optionally take a mask as last argument. In that case only the\n * entries that are selected in the mask are accessed in memory and copied to the\n * vector. This enables invalid indexes in the \\p indexes vector if those are masked\n * off in \\p mask.\n *\n * Gathers from structured data (AoS: arrays of struct) are possible via a special\n * subscript operator of the container (array). You can use \\ref Vc::array and \\ref\n * Vc::vector as drop-in replacements for \\c std::array and \\c std::vector. These\n * container classes contain the necessary subscript operator overload. Example:\n * \\code\n * Vc::vector data(100);\n * std::iota(data.begin(), data.end(), 0.f); // fill with values 0, 1, 2, ...\n * auto indexes = float_v::IndexType::IndexesFromZero();\n * float_v gathered = data[indexes]; // gathered == [0, 1, 2, ...]\n * \\endcode\n *\n * This also works for gathers into arrays of structures:\n * \\code\n * struct Point { float x, y, z; };\n * Vc::array points;\n * // fill points ...\n * auto indexes = float_v::IndexType::IndexesFromZero();\n * float_v xs = data[indexes][&Point::x]; // [points[0].x, points[1].x, points[2].x, ...]\n * float_v ys = data[indexes][&Point::y]; // [points[0].y, points[1].y, points[2].y, ...]\n * float_v zs = data[indexes][&Point::z]; // [points[0].z, points[1].z, points[2].z, ...]\n * \\endcode\n *\n * Alternatively, you can use Vc::Common::AdaptSubscriptOperator to extend a given\n * container class with the necessary subscript operator. Example:\n * \\code\n * template >\n * using my_vector = Vc::Common::AdaptSubscriptOperator>;\n * \\endcode\n *\n * \\param mem A pointer to memory which contains objects of type \\p MT at the offsets\n * given by \\p indexes.\n * \\param indexes A container/vector of offsets into \\p mem.\n * The type of \\p indexes (\\p IT) may either be a pointer to integers\n * (C-array) or a vector of integers (preferrably IndexType).\n * \\param mask If a mask is given, only the active entries will be copied from memory.\n *\n * \\note If you use a masked gather constructor the masked-off entries of the vector\n * are zero-initilized.\n */\n ///@{\n\n /// Gather constructor\n template ::value>>\n Vc_INTRINSIC Vc_CURRENT_CLASS_NAME(const MT *mem, const IT &indexes)\n {\n Vc_ASSERT_GATHER_PARAMETER_TYPES_;\n gatherImplementation(\n Common::make_gather<1>(mem, Common::convertIndexVector(indexes)));\n }\n\n template \n Vc_INTRINSIC Vc_CURRENT_CLASS_NAME(const Common::GatherArguments &args)\n {\n Vc_ASSERT_GATHER_PARAMETER_TYPES_;\n gatherImplementation(args);\n }\n\n /// Masked gather constructor\n template ::value>>\n Vc_INTRINSIC Vc_CURRENT_CLASS_NAME(const MT *mem, const IT &indexes,\n MaskArgument mask)\n {\n Vc_ASSERT_GATHER_PARAMETER_TYPES_;\n gatherImplementation(\n Common::make_gather<1>(mem, Common::convertIndexVector(indexes)), mask);\n }\n\n template \n Vc_INTRINSIC Vc_CURRENT_CLASS_NAME(const Common::GatherArguments &args,\n MaskArgument mask)\n {\n Vc_ASSERT_GATHER_PARAMETER_TYPES_;\n gatherImplementation(args, mask);\n }\n\n /// Gather function\n template ::value>>\n Vc_INTRINSIC void gather(const MT *mem, const IT &indexes)\n {\n Vc_ASSERT_GATHER_PARAMETER_TYPES_;\n gatherImplementation(\n Common::make_gather<1>(mem, Common::convertIndexVector(indexes)));\n }\n\n /// Masked gather function\n template ::value>>\n Vc_INTRINSIC void gather(const MT *mem, const IT &indexes, MaskArgument mask)\n {\n Vc_ASSERT_GATHER_PARAMETER_TYPES_;\n gatherImplementation(\n Common::make_gather<1>(mem, Common::convertIndexVector(indexes)), mask);\n }\n ///@}\n\n#include \"gatherinterface_deprecated.h\"\n\n /**\\internal\n * \\name Gather function to use from Vc::Common::subscript_operator\n *\n * \\param args\n * \\param mask\n */\n ///@{\n template \n Vc_INTRINSIC void gather(const Common::GatherArguments &args)\n {\n Vc_ASSERT_GATHER_PARAMETER_TYPES_;\n gatherImplementation(args);\n }\n\n template \n Vc_INTRINSIC void gather(const Common::GatherArguments &args,\n MaskArgument mask)\n {\n Vc_ASSERT_GATHER_PARAMETER_TYPES_;\n gatherImplementation(args, mask);\n }\n ///@}\n\n#undef Vc_ASSERT_GATHER_PARAMETER_TYPES_\n" }, { "path": "3rdparty/Vc/Vc/common/gatherinterface_deprecated.h", "content": " /// \\name Deprecated Members\n ///@{\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline Vc_CURRENT_CLASS_NAME(const S1 *array,\n const EntryType S1::*member1,\n IT indexes)\n {\n gather(Common::SubscriptOperation, true>(\n array, indexes)[member1]\n .gatherArguments());\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n * \\param mask If a mask is given only the active entries will be gathered/scattered.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline Vc_CURRENT_CLASS_NAME(const S1 *array,\n const EntryType S1::*member1,\n IT indexes, MaskArgument mask)\n {\n gather(Common::SubscriptOperation, true>(\n array, indexes)[member1]\n .gatherArguments(),\n mask);\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param member2 If \\p member1 is a struct then \\p member2 selects the member to be read from that\n * struct (i.e. array[i].*member1.*member2 is read).\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline Vc_CURRENT_CLASS_NAME(const S1 *array,\n const S2 S1::*member1,\n const EntryType S2::*member2,\n IT indexes)\n {\n gather(Common::SubscriptOperation, true>(\n array, indexes)[member1][member2]\n .gatherArguments());\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param member2 If \\p member1 is a struct then \\p member2 selects the member to be read from that\n * struct (i.e. array[i].*member1.*member2 is read).\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n * \\param mask If a mask is given only the active entries will be gathered/scattered.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline Vc_CURRENT_CLASS_NAME(const S1 *array,\n const S2 S1::*member1,\n const EntryType S2::*member2,\n IT indexes, MaskArgument mask)\n {\n gather(Common::SubscriptOperation, true>(\n array, indexes)[member1][member2]\n .gatherArguments(),\n mask);\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param ptrMember1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param outerIndexes\n * \\param innerIndexes\n */\n template \n Vc_DEPRECATED(\n \"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline Vc_CURRENT_CLASS_NAME(const S1 *array,\n const EntryType *const S1::*ptrMember1,\n IT1 outerIndexes, IT2 innerIndexes)\n {\n gather(Common::SubscriptOperation, true>(\n array, outerIndexes)[ptrMember1][innerIndexes]\n .gatherArguments());\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param ptrMember1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param outerIndexes\n * \\param innerIndexes\n * \\param mask If a mask is given only the active entries will be gathered/scattered.\n */\n template \n Vc_DEPRECATED(\n \"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline Vc_CURRENT_CLASS_NAME(const S1 *array,\n const EntryType *const S1::*ptrMember1,\n IT1 outerIndexes, IT2 innerIndexes,\n MaskArgument mask)\n {\n gather(Common::SubscriptOperation, true>(\n array, outerIndexes)[ptrMember1][innerIndexes]\n .gatherArguments(),\n mask);\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void gather(const S1 *array,\n const EntryType S1::*member1, IT indexes)\n {\n gather(Common::SubscriptOperation, true>(\n array, indexes)[member1]\n .gatherArguments());\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n * \\param mask If a mask is given only the active entries will be gathered/scattered.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void gather(const S1 *array,\n const EntryType S1::*member1,\n IT indexes,\n MaskArgument mask)\n {\n gather(Common::SubscriptOperation, true>(\n array, indexes)[member1]\n .gatherArguments(),\n mask);\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param member2 If \\p member1 is a struct then \\p member2 selects the member to be read from that\n * struct (i.e. array[i].*member1.*member2 is read).\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void gather(const S1 *array, const S2 S1::*member1,\n const EntryType S2::*member2, IT indexes)\n {\n gather(Common::SubscriptOperation, true>(\n array, indexes)[member1][member2]\n .gatherArguments());\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param member2 If \\p member1 is a struct then \\p member2 selects the member to be read from that\n * struct (i.e. array[i].*member1.*member2 is read).\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n * \\param mask If a mask is given only the active entries will be gathered/scattered.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void gather(const S1 *array, const S2 S1::*member1,\n const EntryType S2::*member2, IT indexes,\n MaskArgument mask)\n {\n gather(Common::SubscriptOperation, true>(\n array, indexes)[member1][member2]\n .gatherArguments(),\n mask);\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param ptrMember1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param outerIndexes\n * \\param innerIndexes\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void gather(const S1 *array,\n const EntryType *const S1::*ptrMember1,\n IT1 outerIndexes, IT2 innerIndexes)\n {\n gather(Common::SubscriptOperation, true>(\n array, outerIndexes)[ptrMember1][innerIndexes]\n .gatherArguments());\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param ptrMember1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param outerIndexes\n * \\param innerIndexes\n * \\param mask If a mask is given only the active entries will be gathered/scattered.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void gather(const S1 *array,\n const EntryType *const S1::*ptrMember1,\n IT1 outerIndexes, IT2 innerIndexes,\n MaskArgument mask)\n {\n gather(Common::SubscriptOperation, true>(\n array, outerIndexes)[ptrMember1][innerIndexes]\n .gatherArguments(),\n mask);\n }\n ///@}\n" }, { "path": "3rdparty/Vc/Vc/common/generalinterface.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\npublic:\n ///////////////////////////////////////////////////////////////////////////\n // init to zero\n Vc_INTRINSIC Vector() = default;\n\n ///////////////////////////////////////////////////////////////////////////\n // types\n\n ///////////////////////////////////////////////////////////////////////////\n // constants\n static constexpr std::size_t size() { return Size; }\n\n ///////////////////////////////////////////////////////////////////////////\n // constant Vectors\n explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerZero) Vc_INTRINSIC_R;\n explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerOne) Vc_INTRINSIC_R;\n explicit Vc_INTRINSIC_L Vector(VectorSpecialInitializerIndexesFromZero) Vc_INTRINSIC_R;\n static Vc_INTRINSIC Vc_CONST Vector Zero() { return Vector(Vc::Zero); }\n static Vc_INTRINSIC Vc_CONST Vector One() { return Vector(Vc::One); }\n static Vc_INTRINSIC Vc_CONST Vector IndexesFromZero()\n {\n return Vector(Vc::IndexesFromZero);\n }\n\n ///////////////////////////////////////////////////////////////////////////\n // generator ctor\n template ()(size_t())), value_type>::value>::type>\n explicit Vector(G &&g) : Vector(generate(std::forward(g)))\n {\n }\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/iif.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2012-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_IIF_H_\n#define VC_COMMON_IIF_H_\n\n#include \"../type_traits\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n/**\n * \\ingroup Utilities\n *\n * Function to mimic the ternary operator '?:' (inline-if).\n *\n * \\param condition Determines which values are returned. This is analog to the first argument to\n * the ternary operator.\n * \\param trueValue The values to return where \\p condition is \\c true.\n * \\param falseValue The values to return where \\p condition is \\c false.\n * \\return A combination of entries from \\p trueValue and \\p falseValue, according to \\p condition.\n *\n * So instead of the scalar variant\n * \\code\n * float x = a > 1.f ? b : b + c;\n * \\endcode\n * you'd write\n * \\code\n * float_v x = Vc::iif (a > 1.f, b, b + c);\n * \\endcode\n *\n * Assuming \\c a has the values [0, 3, 5, 1], \\c b is [1, 1, 1, 1], and \\c c is [1, 2, 3, 4], then x\n * will be [2, 2, 3, 5].\n */\ntemplate \nVc_ALWAYS_INLINE enable_if::value && is_simd_vector::value, T> iif(\n const Mask &condition, const T &trueValue, const T &falseValue)\n{\n T result(falseValue);\n Vc::where(condition) | result = trueValue;\n return result;\n}\n\n/**\\internal\n * The following declaration makes it explicit that `iif (Mask, non-vector, non-vector)`\n * is not supposed to work. Doing the same thing with \\c static_assert would break SFINAE.\n */\ntemplate \nenable_if::value && !is_simd_vector::value, T> iif(\n const Mask &, const T &, const T &) = delete;\n\n/**\n * \\ingroup Utilities\n *\n * Overload of the above for boolean conditions.\n *\n * This typically results in direct use of the ternary operator. This function makes it easier to\n * switch from a Vc type to a builtin type.\n *\n * \\param condition Determines which value is returned. This is analog to the first argument to\n * the ternary operator.\n * \\param trueValue The value to return if \\p condition is \\c true.\n * \\param falseValue The value to return if \\p condition is \\c false.\n * \\return Either \\p trueValue or \\p falseValue, depending on \\p condition.\n */\ntemplate constexpr T iif (bool condition, const T &trueValue, const T &falseValue)\n{\n return condition ? trueValue : falseValue;\n}\n\n} // namespace Vc\n\n#endif // VC_COMMON_IIF_H_\n" }, { "path": "3rdparty/Vc/Vc/common/indexsequence.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_INDEXSEQUENCE_H_\n#define VC_COMMON_INDEXSEQUENCE_H_\n\n#include \"../global.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n/** \\internal\n * Helper class for a sequence of size_t values from 0 to N. This type will be included in\n * C++14.\n */\ntemplate struct index_sequence\n{\n static constexpr std::size_t size() noexcept { return sizeof...(I); }\n};\n\n/** \\internal\n * This struct builds an index_sequence type from a given upper bound \\p N.\n * It does so recursively via concatenation of to index sequences of length N/2.\n */\ntemplate struct make_index_sequence_impl {\n template \n static index_sequence join(std::false_type,\n index_sequence);\n template \n static index_sequence join(\n std::true_type, index_sequence);\n\n using is_odd = std::integral_constant;\n using half = typename make_index_sequence_impl::type;\n using type = decltype(join<(N + 1) / 2>(is_odd(), half()));\n};\ntemplate <> struct make_index_sequence_impl<0> {\n using type = index_sequence<>;\n};\ntemplate <> struct make_index_sequence_impl<1> {\n using type = index_sequence<0>;\n};\ntemplate <> struct make_index_sequence_impl<2> {\n using type = index_sequence<0, 1>;\n};\n\n/** \\internal\n * Creates an index_sequence type for the upper bound \\p N.\n */\ntemplate \nusing make_index_sequence = typename make_index_sequence_impl::type;\n}\n\n#endif // VC_COMMON_INDEXSEQUENCE_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/interleave.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_INTERLEAVE_H_\n#define VC_COMMON_INTERLEAVE_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n/** \\ingroup Utilities\n Interleaves the entries from \\p a and \\p b into two vectors of the same type. The order\n in the returned vector contains the elements `a[0], b[0], a[1], b[1], a[2], b[2], a[3],\n b[3], ...`.\n\nExample:\n\\code\nVc::SimdArray a = { 1, 2, 3, 4 };\nVc::SimdArray b = { 9, 8, 7, 6 };\nstd::tie(a, b) = Vc::interleave(a, b);\nstd::cout << a << b;\n// prints:\n// <1 9 2 8><3 7 4 6>\n\\endcode\n\n \\param a input vector whose data will appear at even indexes in the output\n \\param b input vector whose data will appear at odd indexes in the output\n \\return two vectors with data from \\p a and \\p b interleaved\n */\ntemplate ::value>>\nstd::pair interleave(const V &a, const V &b)\n{\n return {a.interleaveLow(b), a.interleaveHigh(b)};\n}\n} // namespace Vc\n\n#endif // VC_COMMON_INTERLEAVE_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/interleavedmemory.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2012-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_INTERLEAVEDMEMORY_H_\n#define VC_COMMON_INTERLEAVEDMEMORY_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n/**\n * \\internal\n */\ntemplate struct InterleavedMemoryAccessBase\n{\n // Partial specialization doesn't work for functions without partial specialization of the whole\n // class. Therefore we capture the contents of InterleavedMemoryAccessBase in a macro to easily\n // copy it into its specializations.\n typedef typename std::conditional<\n Readonly, typename std::add_const::type,\n typename V::EntryType>::type T;\n typedef typename V::AsArg VArg;\n typedef T Ta Vc_MAY_ALIAS;\n const I m_indexes;\n Ta *const m_data;\n\n Vc_ALWAYS_INLINE InterleavedMemoryAccessBase(typename I::AsArg indexes, Ta *data)\n : m_indexes(indexes), m_data(data)\n {\n }\n\n // implementations of the following are in {scalar,sse,avx}/detail.h\n template Vc_INTRINSIC void deinterleave(Vs &&... vs) const\n {\n Impl::deinterleave(m_data, m_indexes, std::forward(vs)...);\n }\n\nprotected:\n using Impl = Vc::Detail::InterleaveImpl;\n\n template \n Vc_INTRINSIC void callInterleave(T &&a, index_sequence)\n {\n Impl::interleave(m_data, m_indexes, a[Indexes]...);\n }\n};\n\n/**\n * \\internal\n */\n// delay execution of the deinterleaving gather until operator=\ntemplate \nstruct InterleavedMemoryReadAccess : public InterleavedMemoryAccessBase\n{\n typedef InterleavedMemoryAccessBase Base;\n typedef typename Base::Ta Ta;\n\n Vc_ALWAYS_INLINE InterleavedMemoryReadAccess(Ta *data, typename I::AsArg indexes)\n : Base(StructSize == 1u\n ? indexes\n : StructSize == 2u\n ? indexes << 1\n : StructSize == 4u\n ? indexes << 2\n : StructSize == 8u\n ? indexes << 3\n : StructSize == 16u ? indexes << 4\n : indexes * I(int(StructSize)),\n data)\n {\n }\n\n template \n Vc_ALWAYS_INLINE T deinterleave_unpack(index_sequence) const\n {\n T r;\n Base::Impl::deinterleave(this->m_data, this->m_indexes, std::get(r)...);\n return r;\n }\n\n template ::value &&\n std::is_same(\n std::declval()))>>::value)>>\n Vc_ALWAYS_INLINE operator T() const\n {\n return deinterleave_unpack(make_index_sequence::value>());\n }\n};\n\n///\\internal Runtime check (NDEBUG) for asserting unique indexes.\ntemplate struct CheckIndexesUnique\n{\n#ifdef NDEBUG\n static Vc_INTRINSIC void test(const I &) {}\n#else\n static void test(const I &indexes)\n {\n const I test = indexes.sorted();\n Vc_ASSERT(I::Size == 1 || (test == test.rotated(1)).isEmpty())\n }\n#endif\n};\n///\\internal For SuccessiveEntries there can never be a problem.\ntemplate struct CheckIndexesUnique >\n{\n static Vc_INTRINSIC void test(const SuccessiveEntries &) {}\n};\n\n/**\n * \\internal\n */\ntemplate \nstruct InterleavedMemoryAccess : public InterleavedMemoryReadAccess\n{\n typedef InterleavedMemoryAccessBase Base;\n typedef typename Base::Ta Ta;\n\n Vc_ALWAYS_INLINE InterleavedMemoryAccess(Ta *data, typename I::AsArg indexes)\n : InterleavedMemoryReadAccess(data, indexes)\n {\n CheckIndexesUnique::test(indexes);\n }\n\n template Vc_ALWAYS_INLINE void operator=(VectorReferenceArray &&rhs)\n {\n static_assert(N <= StructSize,\n \"You_are_trying_to_scatter_more_data_into_the_struct_than_it_has\");\n this->callInterleave(std::move(rhs), make_index_sequence());\n }\n template Vc_ALWAYS_INLINE void operator=(VectorReferenceArray &&rhs)\n {\n static_assert(N <= StructSize,\n \"You_are_trying_to_scatter_more_data_into_the_struct_than_it_has\");\n this->callInterleave(std::move(rhs), make_index_sequence());\n }\n};\n\n/**\n * Wraps a pointer to memory with convenience functions to access it via vectors.\n *\n * \\param S The type of the struct.\n * \\param V The type of the vector to be returned when read. This should reflect the type of the\n * members inside the struct.\n *\n * \\see operator[]\n * \\ingroup Containers\n * \\headerfile interleavedmemory.h \n */\ntemplate class InterleavedMemoryWrapper\n{\n typedef typename std::conditional::value,\n const typename V::EntryType,\n typename V::EntryType>::type T;\n typedef typename V::IndexType I;\n typedef typename V::AsArg VArg;\n typedef const I &IndexType;\n static constexpr std::size_t StructSize = sizeof(S) / sizeof(T);\n using ReadAccess = InterleavedMemoryReadAccess;\n using Access =\n typename std::conditional::value, ReadAccess,\n InterleavedMemoryAccess>::type;\n using ReadSuccessiveEntries =\n InterleavedMemoryReadAccess>;\n using AccessSuccessiveEntries = typename std::conditional<\n std::is_const::value, ReadSuccessiveEntries,\n InterleavedMemoryAccess>>::type;\n typedef T Ta Vc_MAY_ALIAS;\n Ta *const m_data;\n\n static_assert(StructSize * sizeof(T) == sizeof(S),\n \"InterleavedMemoryAccess_does_not_support_packed_structs\");\n\npublic:\n /**\n * Constructs the wrapper object.\n *\n * \\param s A pointer to a C-array.\n */\n Vc_ALWAYS_INLINE InterleavedMemoryWrapper(S *s)\n : m_data(reinterpret_cast(s))\n {\n }\n\n /**\n * Interleaved scatter/gather access.\n *\n * Assuming you have a struct of floats and a vector of \\p indexes into the array, this function\n * can be used to access the struct entries as vectors using the minimal number of store or load\n * instructions.\n *\n * \\param indexes Vector of indexes that determine the gather locations.\n *\n * \\return A special (magic) object that executes the loads and deinterleave on assignment to a\n * vector tuple.\n *\n * Example:\n * \\code\n * struct Foo {\n * float x, y, z;\n * };\n *\n * void fillWithBar(Foo *_data, uint_v indexes)\n * {\n * Vc::InterleavedMemoryWrapper data(_data);\n * const float_v x = bar(1);\n * const float_v y = bar(2);\n * const float_v z = bar(3);\n * data[indexes] = (x, y, z);\n * // it's also possible to just store a subset at the front of the struct:\n * data[indexes] = (x, y);\n * // if you want to store a single entry, use scatter:\n * z.scatter(_data, &Foo::x, indexes);\n * }\n *\n * float_v normalizeStuff(Foo *_data, uint_v indexes)\n * {\n * Vc::InterleavedMemoryWrapper data(_data);\n * float_v x, y, z;\n * (x, y, z) = data[indexes];\n * // it is also possible to just load a subset from the front of the struct:\n * // (x, y) = data[indexes];\n * return Vc::sqrt(x * x + y * y + z * z);\n * }\n * \\endcode\n *\n * You may think of the gather operation (or scatter as the inverse) like this:\n\\verbatim\n Memory: {x0 y0 z0 x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4 x5 y5 z5 x6 y6 z6 x7 y7 z7 x8 y8 z8}\n indexes: [5, 0, 1, 7]\nResult in (x, y, z): ({x5 x0 x1 x7}, {y5 y0 y1 y7}, {z5 z0 z1 z7})\n\\endverbatim\n *\n * \\warning If \\p indexes contains non-unique entries on scatter, the result is undefined. If\n * \\c NDEBUG is not defined the implementation will assert that the \\p indexes entries are unique.\n */\n template \n Vc_ALWAYS_INLINE enable_if::value &&\n std::is_convertible::value &&\n !std::is_const::value,\n Access>\n operator[](IT indexes)\n {\n return Access(m_data, indexes);\n }\n\n /// const overload (gathers only) of the above function\n Vc_ALWAYS_INLINE ReadAccess operator[](IndexType indexes) const\n {\n return ReadAccess(m_data, indexes);\n }\n\n /// alias of the above function\n Vc_ALWAYS_INLINE ReadAccess gather(IndexType indexes) const { return operator[](indexes); }\n\n /**\n * Interleaved access.\n *\n * This function is an optimization of the function above, for cases where the index vector\n * contains consecutive values. It will load \\p V::Size consecutive entries from memory and\n * deinterleave them into Vc vectors.\n *\n * \\param first The first of \\p V::Size indizes to be accessed.\n *\n * \\return A special (magic) object that executes the loads and deinterleave on assignment to a\n * vector tuple.\n *\n * Example:\n * \\code\n * struct Foo {\n * float x, y, z;\n * };\n *\n * void foo(Foo *_data)\n * {\n * Vc::InterleavedMemoryWrapper data(_data);\n * for (size_t i = 0; i < 32U; i += float_v::Size) {\n * float_v x, y, z;\n * (x, y, z) = data[i];\n * // now:\n * // x = { _data[i].x, _data[i + 1].x, _data[i + 2].x, ... }\n * // y = { _data[i].y, _data[i + 1].y, _data[i + 2].y, ... }\n * // z = { _data[i].z, _data[i + 1].z, _data[i + 2].z, ... }\n * ...\n * }\n * }\n * \\endcode\n */\n Vc_ALWAYS_INLINE ReadSuccessiveEntries operator[](size_t first) const\n {\n return ReadSuccessiveEntries(m_data, first);\n }\n\n Vc_ALWAYS_INLINE AccessSuccessiveEntries operator[](size_t first)\n {\n return AccessSuccessiveEntries(m_data, first);\n }\n\n //Vc_ALWAYS_INLINE Access scatter(I indexes, VArg v0, VArg v1);\n};\n} // namespace Common\n\nusing Common::InterleavedMemoryWrapper;\n\n/**\n * Creates an adapter around a given array of structure (AoS) that enables optimized loads\n * + deinterleaving operations / interleaving operations + stores for vector access (using\n * \\p V).\n *\n * \\tparam V The `Vc::Vector` type to use per element of the structure.\n * \\param s A pointer to an array of structures containing data members of type `T`.\n *\n * \\see Vc::Common::InterleavedMemoryWrapper\n *\n * \\todo Support destructuring via structured bindings.\n */\ntemplate \ninline Common::InterleavedMemoryWrapper make_interleave_wrapper(S *s)\n{\n return Common::InterleavedMemoryWrapper(s);\n}\n} // namespace Vc\n\n#endif // VC_COMMON_INTERLEAVEDMEMORY_H_\n" }, { "path": "3rdparty/Vc/Vc/common/iterators.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_ITERATORS_H_\n#define VC_COMMON_ITERATORS_H_\n\n#include \n#include \n#ifdef Vc_MSVC\n#include // for _BitScanForward\n#endif // Vc_MSVC\n#include \"where.h\"\n#include \"elementreference.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n\ntemplate class MemoryVector;\ntemplate class MemoryVectorIterator;\n\ntemplate class Iterator;\ntemplate class IteratorBase;\ntemplate class IteratorBase\n{\npublic:\n using iterator_category = std::input_iterator_tag;\n using value_type = typename V::value_type;\n using difference_type = int;\n using reference = value_type;\n Vc_ALWAYS_INLINE reference operator*() const { return v()[i()]; }\n Vc_ALWAYS_INLINE reference operator[](difference_type i2) const { return v()[i2]; }\n\nprivate:\n Vc_INTRINSIC V &v() const { return *static_cast *>(this)->v; }\n Vc_INTRINSIC difference_type i() const\n {\n return static_cast *>(this)->i;\n }\n};\n\ntemplate class IteratorBase\n{\npublic:\n using iterator_category = std::input_iterator_tag;\n using value_type = typename V::value_type;\n using difference_type = int;\n using reference = Vc::Detail::ElementReference;\n Vc_ALWAYS_INLINE reference operator*() const { return {*v(), i()}; }\n Vc_ALWAYS_INLINE reference operator[](difference_type i2) const { return {*v(), i2}; }\n\nprivate:\n Vc_INTRINSIC V *v() const { return static_cast *>(this)->v; }\n Vc_INTRINSIC difference_type i() const\n {\n return static_cast *>(this)->i;\n }\n\n friend reference;\n static Vc_INTRINSIC value_type get(const V &o, int i)\n {\n return o[i];\n }\n template static Vc_INTRINSIC void set(V &o, int i, T &&v)\n {\n o[i] = std::forward(v);\n }\n};\n\n// class Iterator {{{\ntemplate class Iterator : public IteratorBase::value>\n{\n using Base = IteratorBase::value>;\n friend Base;\n\npublic:\n using typename Base::iterator_category;\n using typename Base::value_type;\n using typename Base::difference_type;\n using pointer = const Iterator *;\n using typename Base::reference;\n\n constexpr Iterator() = default;\n constexpr Iterator(V &_v, difference_type _i) : v(&_v), i(_i) {}\n // rely on implicit copy constructor/assignment\n\n Vc_ALWAYS_INLINE pointer operator->() const { return this; }\n using Base::operator*;\n\n Vc_ALWAYS_INLINE Iterator &operator++() { ++i; return *this; }\n Vc_ALWAYS_INLINE Iterator operator++(int) { Iterator tmp = *this; ++i; return tmp; }\n\n // bidirectional iteration is supported\n Vc_ALWAYS_INLINE Iterator &operator--() { --i; return *this; }\n Vc_ALWAYS_INLINE Iterator operator--(int) { Iterator tmp = *this; --i; return tmp; }\n\n // RandomAccessIterator:\n using Base::operator[];\n Vc_ALWAYS_INLINE Iterator &operator+=(difference_type d) { i += d; return *this; }\n Vc_ALWAYS_INLINE Iterator &operator-=(difference_type d) { i -= d; return *this; }\n Vc_ALWAYS_INLINE Iterator operator+(difference_type d) const { return {*v, i + d}; }\n Vc_ALWAYS_INLINE Iterator operator-(difference_type d) const { return {*v, i - d}; }\n Vc_ALWAYS_INLINE difference_type operator-(const Iterator &rhs) const { return i - rhs.i; }\n friend Vc_ALWAYS_INLINE Iterator operator+(difference_type d, const Iterator &rhs)\n {\n return {*rhs.v, rhs.i + d};\n }\n\n // InputIterator would not need to test v == rhs.v, but except for `reference` this\n // class implements a complete RandomAccessIterator\n Vc_ALWAYS_INLINE bool operator==(const Iterator &rhs) const { return v == rhs.v && i == rhs.i; }\n Vc_ALWAYS_INLINE bool operator!=(const Iterator &rhs) const { return v == rhs.v && i != rhs.i; }\n Vc_ALWAYS_INLINE bool operator< (const Iterator &rhs) const { return v == rhs.v && i < rhs.i; }\n Vc_ALWAYS_INLINE bool operator<=(const Iterator &rhs) const { return v == rhs.v && i <= rhs.i; }\n Vc_ALWAYS_INLINE bool operator> (const Iterator &rhs) const { return v == rhs.v && i > rhs.i; }\n Vc_ALWAYS_INLINE bool operator>=(const Iterator &rhs) const { return v == rhs.v && i >= rhs.i; }\n\nprivate:\n V *v = nullptr;\n difference_type i = 0;\n};/*}}}*/\n\ntemplate using ConstIterator = Iterator;\n\n class BitmaskIterator/*{{{*/\n {\n#ifdef Vc_MSVC\n unsigned long mask;\n unsigned long bit;\n#else\n size_t mask;\n size_t bit;\n#endif\n\n void nextBit()\n {\n#ifdef Vc_GNU_ASM\n bit = __builtin_ctzl(mask);\n#elif defined(Vc_MSVC)\n _BitScanForward(&bit, mask);\n#else\n#error \"Not implemented yet. Please contact vc-devel@compeng.uni-frankfurt.de\"\n#endif\n }\n void resetLsb()\n {\n // 01100100 - 1 = 01100011\n mask &= (mask - 1);\n /*\n#ifdef Vc_GNU_ASM\n __asm__(\"btr %1,%0\" : \"+r\"(mask) : \"r\"(bit));\n#elif defined(_WIN64)\n _bittestandreset64(&mask, bit);\n#elif defined(_WIN32)\n _bittestandreset(&mask, bit);\n#else\n#error \"Not implemented yet. Please contact vc-devel@compeng.uni-frankfurt.de\"\n#endif\n */\n }\n public:\n BitmaskIterator(decltype(mask) m) : mask(m) { nextBit(); }\n BitmaskIterator(const BitmaskIterator &) = default;\n BitmaskIterator(BitmaskIterator &&) = default;\n\n Vc_ALWAYS_INLINE size_t operator->() const { return bit; }\n Vc_ALWAYS_INLINE size_t operator*() const { return bit; }\n\n Vc_ALWAYS_INLINE BitmaskIterator &operator++() { resetLsb(); nextBit(); return *this; }\n Vc_ALWAYS_INLINE BitmaskIterator operator++(int) { BitmaskIterator tmp = *this; resetLsb(); nextBit(); return tmp; }\n\n Vc_ALWAYS_INLINE bool operator==(const BitmaskIterator &rhs) const { return mask == rhs.mask; }\n Vc_ALWAYS_INLINE bool operator!=(const BitmaskIterator &rhs) const { return mask != rhs.mask; }\n };/*}}}*/\n\ntemplate \nVc_ALWAYS_INLINE\n enable_if::value || Traits::is_simd_mask::value,\n Iterator::type>>\n begin(T &&x)\n{\n return {std::forward(x), 0};\n}\n\ntemplate \nVc_ALWAYS_INLINE\n enable_if::value || Traits::is_simd_mask::value,\n Iterator::type>>\n end(T &&x)\n{\n using TT = typename std::decay::type;\n return {std::forward(x), int(TT::size())};\n}\n\ntemplate \nVc_ALWAYS_INLINE enable_if<\n Traits::is_simd_mask::value || Traits::is_simd_vector::value, ConstIterator>\ncbegin(const T &v)\n{\n return {v, 0};\n}\n\ntemplate \nVc_ALWAYS_INLINE enable_if<\n Traits::is_simd_mask::value || Traits::is_simd_vector::value, ConstIterator>\ncend(const T &v)\n{\n return {v, int(T::size())};\n}\n\ntemplate Vc_ALWAYS_INLINE BitmaskIterator begin(const WhereImpl::WhereMask &w)\n{\n return w.mask.toInt();\n}\n\ntemplate Vc_ALWAYS_INLINE BitmaskIterator end(const WhereImpl::WhereMask &)\n{\n return 0;\n}\n\ntemplate Vc_ALWAYS_INLINE MemoryVectorIterator\n makeIterator(T *mem, Flags)\n{\n return new(mem) MemoryVector;\n}\n\ntemplate Vc_ALWAYS_INLINE MemoryVectorIterator\n makeIterator(const T *mem, Flags)\n{\n return new(const_cast(mem)) MemoryVector;\n}\n\ntemplate Vc_ALWAYS_INLINE MemoryVectorIterator\n makeIterator(MemoryVector &mv, Flags)\n{\n return new(&mv) MemoryVector;\n}\n\ntemplate Vc_ALWAYS_INLINE MemoryVectorIterator\n makeIterator(MemoryVector &mv, Flags)\n{\n return new(&mv) MemoryVector;\n}\n\n} // namespace Common\n\nusing Common::begin;\nusing Common::end;\nusing Common::cbegin;\nusing Common::cend;\nusing Common::makeIterator;\n} // namespace Vc\n\n#endif // VC_COMMON_ITERATORS_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/loadinterface.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n// load ctors{{{1\n/**\n * Construct a vector from loading its entries from the array at \\p mem.\n *\n * \\param mem A pointer to data. The pointer must not be aligned on a\n * MemoryAlignment boundary unless you add the Vc::Aligned flag as a second\n * argument.\n */\nexplicit Vc_INTRINSIC Vector(const EntryType *mem)\n{\n load(mem);\n}\n/**\n * Construct a vector from loading its entries from the array at \\p mem.\n *\n * \\param mem A pointer to data. If \\p flags contains the Vc::Aligned flag, the pointer\n * must be aligned on a MemoryAlignment boundary.\n * \\param flags A (combination of) flag object(s), such as Vc::Aligned, Vc::Streaming,\n * Vc::Unaligned, and/or Vc::PrefetchDefault.\n */\ntemplate ::value>>\nexplicit Vc_INTRINSIC Vector(const EntryType *mem, Flags flags)\n{\n load(mem, flags);\n}\n\ntemplate ::value || !std::is_integral::value ||\n sizeof(EntryType) >= sizeof(U)) &&\n std::is_arithmetic::value &&Traits::is_load_store_flag::value>>\nexplicit Vc_INTRINSIC Vector(const U *x, Flags flags = Flags())\n{\n load(x, flags);\n}\n\n// load member functions{{{1\n/**\n * Load the vector entries from \\p mem, overwriting the previous values.\n *\n * \\param mem\n * A pointer to data. The pointer must not be aligned on a MemoryAlignment boundary unless\n * you add the Vc::Aligned flag as a second argument.\n */\nVc_INTRINSIC void load(const EntryType *mem)\n{\n load(mem, DefaultLoadTag());\n}\n/**\n * Load the vector entries from \\p mem, overwriting the previous values.\n *\n * \\param mem\n * A pointer to data. If \\p flags contains the Vc::Aligned flag, the pointer must be\n * aligned on a MemoryAlignment boundary.\n * \\param flags\n * A (combination of) flag object(s), such as Vc::Aligned, Vc::Streaming, Vc::Unaligned,\n * and/or Vc::PrefetchDefault.\n */\ntemplate \nVc_INTRINSIC enable_if::value, void>\nload(const EntryType *mem, Flags flags)\n{\n load(mem, flags);\n}\nprivate:\ntemplate \nstruct load_concept : public std::enable_if<\n (!std::is_integral::value || !std::is_integral::value ||\n sizeof(EntryType) >= sizeof(U)) &&\n std::is_arithmetic::value && Traits::is_load_store_flag::value, void>\n{};\n\npublic:\ntemplate \nVc_INTRINSIC_L typename load_concept::type load(const U *mem, Flags = Flags()) Vc_INTRINSIC_R;\n//}}}1\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/loadstoreflags.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_LOADSTOREFLAGS_H_\n#define VC_COMMON_LOADSTOREFLAGS_H_\n\n#include \"../traits/type_traits.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n\n/**\n * Hint for \\ref Prefetch to select prefetches that mark the memory as exclusive.\n *\n * This hint may optimize the prefetch if the memory will subsequently be written to.\n */\nstruct Exclusive {};\n/**\n * Hint for \\ref Prefetch to select prefetches that mark the memory as shared.\n */\nstruct Shared {};\n\nnamespace LoadStoreFlags\n{\n\nstruct StreamingFlag {};\nstruct UnalignedFlag {};\nstruct PrefetchFlagBase {};\n// TODO: determine a good default for typical CPU use\ntemplate \nstruct PrefetchFlag : public PrefetchFlagBase {\n typedef ExclusiveOrShared_ ExclusiveOrShared;\n static constexpr size_t L1Stride = L1;\n static constexpr size_t L2Stride = L2;\n static constexpr bool IsExclusive = std::is_same::value;\n static constexpr bool IsShared = std::is_same::value;\n};\n\ntemplate struct ExtractType\n{\n typedef Default type;\n};\ntemplate struct ExtractType\n{\n typedef typename std::conditional::value, T, typename ExtractType::type>::type type;\n};\n\n// ICC warns about the constexpr members in LoadStoreFlags: member \"LoadStoreFlags::IsAligned\" was declared but never referenced\n// who needs that warning, especially if it was referenced...\n// The warning cannot be reenabled because it gets emitted whenever the LoadStoreFlags is instantiated\n// somewhere, so it could be anywhere.\n#ifdef Vc_ICC\n#pragma warning(disable: 177)\n#endif\n/**\\internal\n * Implementation of the load/store flags mechanism. This is internal API. Only some\n * concrete aliases are API-relevant types.\n */\ntemplate struct LoadStoreFlags\n{\nprivate:\n // ICC doesn't grok this line:\n //template using TestFlag = std::is_same::type, void>;\n typedef typename ExtractType, Flags...>::type Prefetch;\n\npublic:\n constexpr LoadStoreFlags() {}\n\n static constexpr bool IsStreaming = !std::is_same::type, void>::value;\n static constexpr bool IsUnaligned = !std::is_same::type, void>::value;\n static constexpr bool IsAligned = !IsUnaligned;\n static constexpr bool IsPrefetch = !std::is_same::type, void>::value;\n static constexpr bool IsExclusivePrefetch = Prefetch::IsExclusive;\n static constexpr bool IsSharedPrefetch = Prefetch::IsShared;\n static constexpr size_t L1Stride = Prefetch::L1Stride;\n static constexpr size_t L2Stride = Prefetch::L2Stride;\n\n typedef LoadStoreFlags::value, void, Flags>::type...> UnalignedRemoved;\n\n // The following EnableIf* convenience types cannot use enable_if because then no LoadStoreFlags type\n // could ever be instantiated. Instead these types are defined either as void* or void. The\n // function that does SFINAE then assigns \"= nullptr\" to this type. Thus, the ones with just\n // void result in substitution failure.\n typedef typename std::conditional::type EnableIfAligned;\n typedef typename std::conditional::type EnableIfStreaming;\n typedef typename std::conditional::type EnableIfUnalignedNotStreaming;\n typedef typename std::conditional::type EnableIfUnalignedAndStreaming;\n typedef typename std::conditional::type EnableIfUnaligned;\n typedef typename std::conditional::type EnableIfNotUnaligned;\n typedef typename std::conditional::type EnableIfPrefetch;\n typedef typename std::conditional::type EnableIfNotPrefetch;\n};\n\n/**\\internal\n * Specialization for no flags (i.e aligned, non-streaming, no prefetching)\n */\ntemplate<> struct LoadStoreFlags<>\n{\n constexpr LoadStoreFlags() {}\n\n static constexpr bool IsStreaming = false;\n static constexpr bool IsUnaligned = false;\n static constexpr bool IsAligned = !IsUnaligned;\n static constexpr bool IsPrefetch = false;\n static constexpr bool IsExclusivePrefetch = false;\n static constexpr bool IsSharedPrefetch = false;\n static constexpr size_t L1Stride = 0;\n static constexpr size_t L2Stride = 0;\n typedef void* EnableIfAligned;\n typedef void* EnableIfNotUnaligned;\n typedef void* EnableIfNotPrefetch;\n};\n\n/**\n * Operator for concatenation of LoadStoreFlags.\n *\n * Example:\n * \\code\n * float_v x(mem, Vc::Aligned | Vc::Streaming);\n * \\endcode\n */\ntemplate\nconstexpr LoadStoreFlags operator|(LoadStoreFlags, LoadStoreFlags)\n{\n return LoadStoreFlags();\n}\n\n} // LoadStoreFlags namespace\n\nusing LoadStoreFlags::PrefetchFlag;\n\ntypedef LoadStoreFlags::LoadStoreFlags<> AlignedTag;\ntypedef LoadStoreFlags::LoadStoreFlags StreamingTag;\ntypedef LoadStoreFlags::LoadStoreFlags UnalignedTag;\n\n/// The default load tag type uses unaligned (non-streaming) loads.\ntypedef UnalignedTag DefaultLoadTag;\n/// The default store tag type uses unaligned (non-streaming) stores.\ntypedef UnalignedTag DefaultStoreTag;\n\n/**\\addtogroup Utilities\n * @{\n */\n/**\n * Use this object for a \\p flags parameter to request aligned loads and stores.\n *\n * It specifies that a load/store can expect a memory address that is aligned on\n * the correct boundary. (i.e. \\p MemoryAlignment)\n *\n * \\warning\n * If you specify Aligned, but the memory address is not aligned the program\n * will most likely crash.\n */\nconstexpr AlignedTag Aligned;\n\n/**\n * Use this object for a \\p flags parameter to request unaligned loads and stores.\n *\n * It specifies that a load/store can \\em not expect a memory address that is\n * aligned on the correct boundary. (i.e. alignment is less than\n * \\p MemoryAlignment)\n *\n * \\note\n * If you specify Unaligned, but the memory address is aligned the load/store\n * will execute slightly slower than necessary.\n */\nconstexpr UnalignedTag Unaligned;\n\n/**\n * Use this object for a \\p flags parameter to request streaming loads and stores.\n *\n * It specifies that the cache should be bypassed for the given load/store.\n * Whether this will actually be done depends on the target system's capabilities.\n *\n * Streaming stores can be interesting when the code calculates values that, after being\n * written to memory, will not be used for a long time or used by a different thread.\n *\n * \\note\n * Expect that most target systems do not support unaligned streaming loads or stores.\n * Therefore, make sure that you also specify Aligned.\n */\nconstexpr StreamingTag Streaming;\n\n/**\n * Use this object for a \\p flags parameter to request default software prefetches to be\n * emitted.\n */\nconstexpr LoadStoreFlags::LoadStoreFlags> PrefetchDefault;\n///@}\n\n/**\n * \\tparam L1\n * \\tparam L2\n * \\tparam ExclusiveOrShared\n */\ntemplate ::L1Stride,\n size_t L2 = PrefetchFlag<>::L2Stride,\n typename ExclusiveOrShared = PrefetchFlag<>::ExclusiveOrShared>\nstruct Prefetch : public LoadStoreFlags::LoadStoreFlags>\n{\n};\n\nnamespace Traits\n{\n///\\internal partial specialization for detecting LoadStoreFlags types\ntemplate \nstruct is_loadstoreflag_internal> : public std::true_type\n{\n};\n///\\internal partial specialization for detecting the derived Prefetch type as a\n/// load/store flag.\ntemplate \nstruct is_loadstoreflag_internal> : public std::true_type\n{\n};\n} // namespace Traits\n} // namespace Vc\n\n#endif // VC_COMMON_LOADSTOREFLAGS_H_\n" }, { "path": "3rdparty/Vc/Vc/common/logarithm.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n/* The log implementations are based on code from Julien Pommier which carries the following\n copyright information:\n */\n/*\n Inspired by Intel Approximate Math library, and based on the\n corresponding algorithms of the cephes math library\n*/\n/* Copyright (C) 2007 Julien Pommier\n\n This software is provided 'as-is', without any express or implied\n warranty. In no event will the authors be held liable for any damages\n arising from the use of this software.\n\n Permission is granted to anyone to use this software for any purpose,\n including commercial applications, and to alter it and redistribute it\n freely, subject to the following restrictions:\n\n 1. The origin of this software must not be misrepresented; you must not\n claim that you wrote the original software. If you use this software\n in a product, an acknowledgment in the product documentation would be\n appreciated but is not required.\n 2. Altered source versions must be plainly marked as such, and must not be\n misrepresented as being the original software.\n 3. This notice may not be removed or altered from any source distribution.\n\n (this is the zlib license)\n*/\n\n#ifdef Vc_COMMON_MATH_H_INTERNAL\n\nenum LogarithmBase {\n BaseE, Base10, Base2\n};\n\nnamespace Detail\n{\ntemplate \nusing Const = typename std::conditional::value,\n AVX::Const, SSE::Const>::type;\n\ntemplate\nstruct LogImpl\n{\n template static Vc_ALWAYS_INLINE void log_series(Vector &Vc_RESTRICT x, typename Vector::AsArg exponent) {\n typedef Vector V;\n typedef Detail::Const C;\n // Taylor series around x = 2^exponent\n // f(x) = ln(x) → exponent * ln(2) → C::ln2_small + C::ln2_large\n // f'(x) = x⁻¹ → x → 1\n // f''(x) = - x⁻² → -x² / 2 → C::_1_2()\n // = 2!x⁻³ → x³ / 3 → C::P(8)\n // = -3!x⁻⁴ → -x⁴ / 4 → C::P(7)\n // = 4!x⁻⁵ → x⁵ / 5 → C::P(6)\n // ...\n // The high order coefficients are adjusted to reduce the error that occurs from ommission\n // of higher order terms.\n // P(0) is the smallest term and |x| < 1 ⇒ |xⁿ| > |xⁿ⁺¹|\n // The order of additions must go from smallest to largest terms\n const V x2 = x * x; // 0 → 4\n#ifdef Vc_LOG_ILP\n V y2 = (C::P(6) * /*4 → 8*/ x2 + /* 8 → 11*/ C::P(7) * /*1 → 5*/ x) + /*11 → 14*/ C::P(8);\n V y0 = (C::P(0) * /*5 → 9*/ x2 + /* 9 → 12*/ C::P(1) * /*2 → 6*/ x) + /*12 → 15*/ C::P(2);\n V y1 = (C::P(3) * /*6 → 10*/ x2 + /*10 → 13*/ C::P(4) * /*3 → 7*/ x) + /*13 → 16*/ C::P(5);\n const V x3 = x2 * x; // 7 → 11\n const V x6 = x3 * x3; // 11 → 15\n const V x9 = x6 * x3; // 15 → 19\n V y = (y0 * /*19 → 23*/ x9 + /*23 → 26*/ y1 * /*16 → 20*/ x6) + /*26 → 29*/ y2 * /*14 → 18*/ x3;\n#elif defined Vc_LOG_ILP2\n /*\n * name start done\n * movaps %xmm0, %xmm1 ; x 0 1\n * movaps %xmm0, %xmm2 ; x 0 1\n * mulps %xmm1, %xmm1 ; x2 1 5 *xmm1\n * movaps , %xmm15 ; y8 1 2\n * mulps %xmm1, %xmm2 ; x3 5 9 *xmm2\n * movaps %xmm1, %xmm3 ; x2 5 6\n * movaps %xmm1, %xmm4 ; x2 5 6\n * mulps %xmm3, %xmm3 ; x4 6 10 *xmm3\n * movaps %xmm2, %xmm5 ; x3 9 10\n * movaps %xmm2, %xmm6 ; x3 9 10\n * mulps %xmm2, %xmm4 ; x5 9 13 *xmm4\n * movaps %xmm3, %xmm7 ; x4 10 11\n * movaps %xmm3, %xmm8 ; x4 10 11\n * movaps %xmm3, %xmm9 ; x4 10 11\n * mulps %xmm5, %xmm5 ; x6 10 14 *xmm5\n * mulps %xmm3, %xmm6 ; x7 11 15 *xmm6\n * mulps %xmm7, %xmm7 ; x8 12 16 *xmm7\n * movaps %xmm4, %xmm10 ; x5 13 14\n * mulps %xmm4, %xmm8 ; x9 13 17 *xmm8\n * mulps %xmm5, %xmm10 ; x11 14 18 *xmm10\n * mulps %xmm5, %xmm9 ; x10 15 19 *xmm9\n * mulps , %xmm10 ; y0 18 22\n * mulps , %xmm9 ; y1 19 23\n * mulps , %xmm8 ; y2 20 24\n * mulps , %xmm7 ; y3 21 25\n * addps %xmm10, %xmm9 ; y 23 26\n * addps %xmm9, %xmm8 ; y 26 29\n * addps %xmm8, %xmm7 ; y 29 32\n */\n const V x3 = x2 * x; // 4 → 8\n const V x4 = x2 * x2; // 5 → 9\n const V x5 = x2 * x3; // 8 → 12\n const V x6 = x3 * x3; // 9 → 13\n const V x7 = x4 * x3; // \n const V x8 = x4 * x4;\n const V x9 = x5 * x4;\n const V x10 = x5 * x5;\n const V x11 = x5 * x6; // 13 → 17\n V y = C::P(0) * x11 + C::P(1) * x10 + C::P(2) * x9 + C::P(3) * x8 + C::P(4) * x7\n + C::P(5) * x6 + C::P(6) * x5 + C::P(7) * x4 + C::P(8) * x3;\n#else\n V y = C::P(0);\n Vc::Common::unrolled_loop([&](int i) { y = y * x + C::P(i); });\n y *= x * x2;\n#endif\n switch (Base) {\n case BaseE:\n // ln(2) is split in two parts to increase precision (i.e. ln2_small + ln2_large = ln(2))\n y += exponent * C::ln2_small();\n y -= x2 * C::_1_2(); // [0, 0.25[\n x += y;\n x += exponent * C::ln2_large();\n break;\n case Base10:\n y += exponent * C::ln2_small();\n y -= x2 * C::_1_2(); // [0, 0.25[\n x += y;\n x += exponent * C::ln2_large();\n x *= C::log10_e();\n break;\n case Base2:\n {\n const V x_ = x;\n x *= C::log2_e();\n y *= C::log2_e();\n y -= x_ * x * C::_1_2(); // [0, 0.25[\n x += y;\n x += exponent;\n break;\n }\n }\n }\n\ntemplate \nstatic Vc_ALWAYS_INLINE void log_series(Vector &Vc_RESTRICT x,\n typename Vector::AsArg exponent)\n{\n typedef Vector V;\n typedef Detail::Const C;\n const V x2 = x * x;\n V y = C::P(0);\n V y2 = C::Q(0) + x;\n Vc::Common::unrolled_loop([&](int i) {\n y = y * x + C::P(i);\n y2 = y2 * x + C::Q(i);\n });\n y2 = x / y2;\n y = y * x + C::P(5);\n y = x2 * y * y2;\n // TODO: refactor the following with the float implementation:\n switch (Base) {\n case BaseE:\n // ln(2) is split in two parts to increase precision (i.e. ln2_small + ln2_large = ln(2))\n y += exponent * C::ln2_small();\n y -= x2 * C::_1_2(); // [0, 0.25[\n x += y;\n x += exponent * C::ln2_large();\n break;\n case Base10:\n y += exponent * C::ln2_small();\n y -= x2 * C::_1_2(); // [0, 0.25[\n x += y;\n x += exponent * C::ln2_large();\n x *= C::log10_e();\n break;\n case Base2:\n {\n const V x_ = x;\n x *= C::log2_e();\n y *= C::log2_e();\n y -= x_ * x * C::_1_2(); // [0, 0.25[\n x += y;\n x += exponent;\n break;\n }\n }\n }\n\ntemplate >\nstatic inline Vector calc(V _x)\n{\n typedef typename V::Mask M;\n typedef Detail::Const C;\n\n V x(_x);\n\n const M invalidMask = x < V::Zero();\n const M infinityMask = x == V::Zero();\n const M denormal = x <= C::min();\n\n x(denormal) *= V(Vc::Detail::doubleConstant<1, 0, 54>()); // 2²⁵\n V exponent = Detail::exponent(x.data()); // = ⎣log₂(x)⎦\n exponent(denormal) -= 54;\n\n x.setZero(C::exponentMask()); // keep only the fractional part ⇒ x ∈ [1, 2[\n x = Detail::operator|(x,\n C::_1_2()); // and set the exponent to 2⁻¹ ⇒ x ∈ [½, 1[\n\n // split calculation in two cases:\n // A: x ∈ [½, √½[\n // B: x ∈ [√½, 1[\n // √½ defines the point where Δe(x) := log₂(x) - ⎣log₂(x)⎦ = ½, i.e.\n // log₂(√½) - ⎣log₂(√½)⎦ = ½ * -1 - ⎣½ * -1⎦ = -½ + 1 = ½\n\n const M smallX = x < C::_1_sqrt2();\n x(smallX) += x; // => x ∈ [√½, 1[ ∪ [1.5, 1 + √½[\n x -= V::One(); // => x ∈ [√½ - 1, 0[ ∪ [0.5, √½[\n exponent(!smallX) += V::One();\n\n log_series(x, exponent); // A: (ˣ⁄₂ᵉ - 1, e) B: (ˣ⁄₂ᵉ⁺¹ - 1, e + 1)\n\n x.setQnan(invalidMask); // x < 0 → NaN\n x(infinityMask) = C::neginf(); // x = 0 → -∞\n\n return x;\n }\n};\n} // namespace Detail\n\ntemplate \nVc_INTRINSIC Vc_CONST Vector> log(\n const Vector &x)\n{\n return Detail::LogImpl::calc(x);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Vector> log10(\n const Vector &x)\n{\n return Detail::LogImpl::calc(x);\n}\ntemplate \nVc_INTRINSIC Vc_CONST Vector> log2(\n const Vector &x)\n{\n return Detail::LogImpl::calc(x);\n}\n\n#endif // Vc_COMMON_MATH_H_INTERNAL\n" }, { "path": "3rdparty/Vc/Vc/common/macros.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2010-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MACROS_H_\n#define VC_COMMON_MACROS_H_\n\n#include \"../global.h\"\n\n\n#ifdef Vc_MSVC\n#define Vc_ALIGNED_TYPEDEF(n_, type_, new_type_) \\\n typedef __declspec(align(n_)) type_ new_type_\n#elif __GNUC__\n#define Vc_ALIGNED_TYPEDEF(n_, type_, new_type_) \\\n typedef type_ new_type_[[gnu::aligned(n_)]]\n#else // the following is actually ill-formed according to C++1[14]\n#define Vc_ALIGNED_TYPEDEF(n_, type_, new_type_) \\\n using new_type_ alignas(sizeof(n_)) = type_\n#endif\n\n// On Windows (WIN32) we might see macros called min and max. Just undefine them and hope\n// noone (re)defines them (NOMINMAX should help).\n#ifdef WIN32\n#define NOMINMAX 1\n#if defined min\n#undef min\n#endif\n#if defined max\n#undef max\n#endif\n#endif // WIN32\n\n#if defined Vc_GCC && Vc_GCC >= 0x60000\n// GCC 6 drops all attributes on types passed as template arguments. This is important\n// if a may_alias gets lost and therefore needs to be readded in the implementation of\n// the class template.\n#define Vc_TEMPLATES_DROP_ATTRIBUTES 1\n#endif\n\n#if defined Vc_CLANG || defined Vc_APPLECLANG\n# define Vc_UNREACHABLE __builtin_unreachable\n# define Vc_NEVER_INLINE [[gnu::noinline]]\n# define Vc_INTRINSIC_L inline\n# define Vc_INTRINSIC_R __attribute__((always_inline))\n# define Vc_INTRINSIC Vc_INTRINSIC_L Vc_INTRINSIC_R\n# define Vc_FLATTEN\n# define Vc_CONST __attribute__((const))\n# define Vc_CONST_L\n# define Vc_CONST_R Vc_CONST\n# define Vc_PURE __attribute__((pure))\n# define Vc_PURE_L\n# define Vc_PURE_R Vc_PURE\n# define Vc_MAY_ALIAS __attribute__((may_alias))\n# define Vc_ALWAYS_INLINE_L inline\n# define Vc_ALWAYS_INLINE_R __attribute__((always_inline))\n# define Vc_ALWAYS_INLINE Vc_ALWAYS_INLINE_L Vc_ALWAYS_INLINE_R\n# define Vc_IS_UNLIKELY(x) __builtin_expect(x, 0)\n# define Vc_IS_LIKELY(x) __builtin_expect(x, 1)\n# define Vc_RESTRICT __restrict__\n# define Vc_DEPRECATED(msg)\n# define Vc_DEPRECATED_ALIAS(msg)\n# define Vc_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))\n#elif defined(__GNUC__)\n# define Vc_UNREACHABLE __builtin_unreachable\n# if defined Vc_GCC && !defined __OPTIMIZE__\n# define Vc_MAY_ALIAS\n# else\n# define Vc_MAY_ALIAS __attribute__((__may_alias__))\n# endif\n# define Vc_INTRINSIC_R __attribute__((__always_inline__, __artificial__))\n# define Vc_INTRINSIC_L inline\n# define Vc_INTRINSIC Vc_INTRINSIC_L Vc_INTRINSIC_R\n# define Vc_FLATTEN __attribute__((__flatten__))\n# define Vc_ALWAYS_INLINE_L inline\n# define Vc_ALWAYS_INLINE_R __attribute__((__always_inline__))\n# define Vc_ALWAYS_INLINE Vc_ALWAYS_INLINE_L Vc_ALWAYS_INLINE_R\n# ifdef Vc_ICC\n// ICC miscompiles if there are functions marked as pure or const\n# define Vc_PURE\n# define Vc_CONST\n# define Vc_NEVER_INLINE\n# else\n# define Vc_NEVER_INLINE [[gnu::noinline]]\n# define Vc_PURE __attribute__((__pure__))\n# define Vc_CONST __attribute__((__const__))\n# endif\n# define Vc_CONST_L\n# define Vc_CONST_R Vc_CONST\n# define Vc_PURE_L\n# define Vc_PURE_R Vc_PURE\n# define Vc_IS_UNLIKELY(x) __builtin_expect(x, 0)\n# define Vc_IS_LIKELY(x) __builtin_expect(x, 1)\n# define Vc_RESTRICT __restrict__\n# ifdef Vc_ICC\n# define Vc_DEPRECATED(msg)\n# define Vc_DEPRECATED_ALIAS(msg)\n# else\n# define Vc_DEPRECATED(msg) __attribute__((__deprecated__(msg)))\n# define Vc_DEPRECATED_ALIAS(msg) __attribute__((__deprecated__(msg)))\n# endif\n# define Vc_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))\n#else\n# define Vc_NEVER_INLINE\n# define Vc_FLATTEN\n# ifdef Vc_PURE\n# undef Vc_PURE\n# endif\n# define Vc_MAY_ALIAS\n# ifdef Vc_MSVC\n# define Vc_ALWAYS_INLINE inline __forceinline\n# define Vc_ALWAYS_INLINE_L Vc_ALWAYS_INLINE\n# define Vc_ALWAYS_INLINE_R\n# define Vc_CONST __declspec(noalias)\n# define Vc_CONST_L Vc_CONST\n# define Vc_CONST_R\n# define Vc_PURE /*Vc_CONST*/\n# define Vc_PURE_L Vc_PURE\n# define Vc_PURE_R\n# define Vc_INTRINSIC inline __forceinline\n# define Vc_INTRINSIC_L Vc_INTRINSIC\n# define Vc_INTRINSIC_R\nnamespace Vc_VERSIONED_NAMESPACE {\nnamespace detail\n{\nstatic Vc_INTRINSIC void unreachable() { __assume(0); }\n} // namespace detail\n}\n# define Vc_UNREACHABLE Vc::detail::unreachable\n# else\n# define Vc_ALWAYS_INLINE\n# define Vc_ALWAYS_INLINE_L\n# define Vc_ALWAYS_INLINE_R\n# define Vc_CONST\n# define Vc_CONST_L\n# define Vc_CONST_R\n# define Vc_PURE\n# define Vc_PURE_L\n# define Vc_PURE_R\n# define Vc_INTRINSIC\n# define Vc_INTRINSIC_L\n# define Vc_INTRINSIC_R\n# define Vc_UNREACHABLE std::abort\n# endif\n# define Vc_IS_UNLIKELY(x) x\n# define Vc_IS_LIKELY(x) x\n# define Vc_RESTRICT __restrict\n# define Vc_DEPRECATED(msg) __declspec(deprecated(msg))\n# define Vc_DEPRECATED_ALIAS(msg)\n# define Vc_WARN_UNUSED_RESULT\n#endif\n\n#ifdef Vc_CXX14\n#undef Vc_DEPRECATED\n#define Vc_DEPRECATED(msg_) [[deprecated(msg_)]]\n#endif\n\n#define Vc_NOTHING_EXPECTING_SEMICOLON static_assert(true, \"\")\n\n#define Vc_FREE_STORE_OPERATORS_ALIGNED(align_) \\\n /**\\name new/delete overloads for correct alignment */ \\\n /**@{*/ \\\n /*!\\brief Allocates correctly aligned memory */ \\\n Vc_ALWAYS_INLINE void *operator new(size_t size) \\\n { \\\n return Vc::Common::aligned_malloc(size); \\\n } \\\n /*!\\brief Returns \\p p. */ \\\n Vc_ALWAYS_INLINE void *operator new(size_t, void *p) { return p; } \\\n /*!\\brief Allocates correctly aligned memory */ \\\n Vc_ALWAYS_INLINE void *operator new[](size_t size) \\\n { \\\n return Vc::Common::aligned_malloc(size); \\\n } \\\n /*!\\brief Returns \\p p. */ \\\n Vc_ALWAYS_INLINE void *operator new[](size_t, void *p) { return p; } \\\n /*!\\brief Frees aligned memory. */ \\\n Vc_ALWAYS_INLINE void operator delete(void *ptr, size_t) { Vc::Common::free(ptr); } \\\n /*!\\brief Does nothing. */ \\\n Vc_ALWAYS_INLINE void operator delete(void *, void *) {} \\\n /*!\\brief Frees aligned memory. */ \\\n Vc_ALWAYS_INLINE void operator delete[](void *ptr, size_t) \\\n { \\\n Vc::Common::free(ptr); \\\n } \\\n /*!\\brief Does nothing. */ \\\n Vc_ALWAYS_INLINE void operator delete[](void *, void *) {} \\\n /**@}*/ \\\n Vc_NOTHING_EXPECTING_SEMICOLON\n\n#ifdef Vc_ASSERT\n#define Vc_EXTERNAL_ASSERT 1\n#else\n#ifdef NDEBUG\n#define Vc_ASSERT(x)\n#else\n#include \n#define Vc_ASSERT(x) assert(x);\n#endif\n#endif\n\n#if defined Vc_CLANG || defined Vc_APPLECLANG\n#define Vc_HAS_BUILTIN(x) __has_builtin(x)\n#else\n#define Vc_HAS_BUILTIN(x) 0\n#endif\n\n#define Vc_CAT_HELPER_(a, b, c, d) a##b##c##d\n#define Vc_CAT(a, b, c, d) Vc_CAT_HELPER_(a, b, c, d)\n\n#define Vc_CAT_IMPL(a, b) a##b\n#define Vc_CAT2(a, b) Vc_CAT_IMPL(a, b)\n\n#define Vc_APPLY_IMPL_1_(macro, a, b, c, d, e) macro(a)\n#define Vc_APPLY_IMPL_2_(macro, a, b, c, d, e) macro(a, b)\n#define Vc_APPLY_IMPL_3_(macro, a, b, c, d, e) macro(a, b, c)\n#define Vc_APPLY_IMPL_4_(macro, a, b, c, d, e) macro(a, b, c, d)\n#define Vc_APPLY_IMPL_5_(macro, a, b, c, d, e) macro(a, b, c, d, e)\n\n#define Vc_LIST_FLOAT_VECTOR_TYPES(size, macro, a, b, c, d) \\\n size(macro, double_v, a, b, c, d) \\\n size(macro, float_v, a, b, c, d)\n#define Vc_LIST_INT_VECTOR_TYPES(size, macro, a, b, c, d) \\\n size(macro, int_v, a, b, c, d) \\\n size(macro, uint_v, a, b, c, d) \\\n size(macro, short_v, a, b, c, d) \\\n size(macro, ushort_v, a, b, c, d)\n#define Vc_LIST_VECTOR_TYPES(size, macro, a, b, c, d) \\\n Vc_LIST_FLOAT_VECTOR_TYPES(size, macro, a, b, c, d) \\\n Vc_LIST_INT_VECTOR_TYPES(size, macro, a, b, c, d)\n#define Vc_LIST_COMPARES(size, macro, a, b, c, d) \\\n size(macro, ==, a, b, c, d) \\\n size(macro, !=, a, b, c, d) \\\n size(macro, <=, a, b, c, d) \\\n size(macro, >=, a, b, c, d) \\\n size(macro, < , a, b, c, d) \\\n size(macro, > , a, b, c, d)\n#define Vc_LIST_LOGICAL(size, macro, a, b, c, d) \\\n size(macro, &&, a, b, c, d) \\\n size(macro, ||, a, b, c, d)\n#define Vc_LIST_BINARY(size, macro, a, b, c, d) \\\n size(macro, |, a, b, c, d) \\\n size(macro, &, a, b, c, d) \\\n size(macro, ^, a, b, c, d)\n#define Vc_LIST_SHIFTS(size, macro, a, b, c, d) \\\n size(macro, <<, a, b, c, d) \\\n size(macro, >>, a, b, c, d)\n#define Vc_LIST_ARITHMETICS(size, macro, a, b, c, d) \\\n size(macro, +, a, b, c, d) \\\n size(macro, -, a, b, c, d) \\\n size(macro, *, a, b, c, d) \\\n size(macro, /, a, b, c, d) \\\n size(macro, %, a, b, c, d)\n\n#define Vc_APPLY_0(_list, macro) _list(Vc_APPLY_IMPL_1_, macro, 0, 0, 0, 0) Vc_NOTHING_EXPECTING_SEMICOLON\n#define Vc_APPLY_1(_list, macro, a) _list(Vc_APPLY_IMPL_2_, macro, a, 0, 0, 0) Vc_NOTHING_EXPECTING_SEMICOLON\n#define Vc_APPLY_2(_list, macro, a, b) _list(Vc_APPLY_IMPL_3_, macro, a, b, 0, 0) Vc_NOTHING_EXPECTING_SEMICOLON\n#define Vc_APPLY_3(_list, macro, a, b, c) _list(Vc_APPLY_IMPL_4_, macro, a, b, c, 0) Vc_NOTHING_EXPECTING_SEMICOLON\n#define Vc_APPLY_4(_list, macro, a, b, c, d) _list(Vc_APPLY_IMPL_5_, macro, a, b, c, d) Vc_NOTHING_EXPECTING_SEMICOLON\n\n#define Vc_ALL_COMPARES(macro) Vc_APPLY_0(Vc_LIST_COMPARES, macro)\n#define Vc_ALL_LOGICAL(macro) Vc_APPLY_0(Vc_LIST_LOGICAL, macro)\n#define Vc_ALL_BINARY(macro) Vc_APPLY_0(Vc_LIST_BINARY, macro)\n#define Vc_ALL_SHIFTS(macro) Vc_APPLY_0(Vc_LIST_SHIFTS, macro)\n#define Vc_ALL_ARITHMETICS(macro) Vc_APPLY_0(Vc_LIST_ARITHMETICS, macro)\n#define Vc_ALL_FLOAT_VECTOR_TYPES(macro) Vc_APPLY_0(Vc_LIST_FLOAT_VECTOR_TYPES, macro)\n#define Vc_ALL_VECTOR_TYPES(macro) Vc_APPLY_0(Vc_LIST_VECTOR_TYPES, macro)\n\n#define Vc_EXACT_TYPE(_test, _reference, _type) \\\n typename std::enable_if::value, _type>::type\n\n#define Vc_make_unique(name) Vc_CAT(Vc_,name,_,__LINE__)\n\n#if defined(Vc_NO_NOEXCEPT)\n#define Vc_NOEXCEPT throw()\n#else\n#define Vc_NOEXCEPT noexcept\n#endif\n\n#ifdef Vc_NO_ALWAYS_INLINE\n#undef Vc_ALWAYS_INLINE\n#undef Vc_ALWAYS_INLINE_L\n#undef Vc_ALWAYS_INLINE_R\n#define Vc_ALWAYS_INLINE inline\n#define Vc_ALWAYS_INLINE_L inline\n#define Vc_ALWAYS_INLINE_R\n#undef Vc_INTRINSIC\n#undef Vc_INTRINSIC_L\n#undef Vc_INTRINSIC_R\n#define Vc_INTRINSIC inline\n#define Vc_INTRINSIC_L inline\n#define Vc_INTRINSIC_R\n#endif\n\n#endif // VC_COMMON_MACROS_H_\n" }, { "path": "3rdparty/Vc/Vc/common/makeContainer.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MAKECONTAINER_H_\n#define VC_COMMON_MAKECONTAINER_H_\n\n#include \"../vector.h\"\n#include \n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n\n namespace\n {\n template struct make_container_helper\n {\n static constexpr Container help(std::initializer_list list) { return { list }; }\n };\n\n template class Container>\n struct make_container_helper, Alloc>,\n typename Vector::EntryType> {\n typedef Vector V;\n typedef typename V::EntryType T;\n typedef Container C;\n static inline C help(std::initializer_list list) {\n const std::size_t size = (list.size() + (V::Size - 1)) / V::Size;\n C v(size);\n auto containerIt = v.begin();\n auto init = std::begin(list);\n const auto initEnd = std::end(list);\n for (std::size_t i = 0; i < size - 1; ++i) {\n *containerIt++ = V(init, Vc::Unaligned);\n init += V::Size;\n }\n Vc_ASSERT(all_of(*containerIt == V::Zero()));\n int j = 0;\n while (init != initEnd) {\n (*containerIt)[j++] = *init++;\n }\n return v;\n }\n };\n\n template class Container>\n struct make_container_helper, N>,\n typename Vector::EntryType> {\n typedef Vector V;\n typedef typename V::EntryType T;\n static constexpr std::size_t size = (N + (V::Size - 1)) / V::Size;\n typedef Container<\n V,\n#if defined Vc_CLANG && Vc_CLANG < 0x30700 // TODO: when did Vc_APPLECLANG fix it?\n // clang before 3.7.0 has a bug when returning std::array<__m256x, 1>. So\n // increase it to std::array<__m256x, 2> and fill it with zeros. Better\n // than returning garbage.\n (size == 1 && std::is_same::value) ? 2 :\n#endif\n size> C;\n static inline C help(std::initializer_list list) {\n Vc_ASSERT(N == list.size())\n Vc_ASSERT(size == (list.size() + (V::Size - 1)) / V::Size)\n C v;\n auto containerIt = v.begin();\n auto init = std::begin(list);\n const auto initEnd = std::end(list);\n for (std::size_t i = 0; i < size - 1; ++i) {\n *containerIt++ = V(init, Vc::Unaligned);\n init += V::Size;\n }\n Vc_ASSERT(all_of(*containerIt == V::Zero()));\n int j = 0;\n while (init != initEnd) {\n (*containerIt)[j++] = *init++;\n }\n return v;\n }\n };\n } // anonymous namespace\n\n /**\n * \\ingroup Containers\n * \\headerfile makeContainer.h \n *\n * Construct a container of Vc vectors from a std::initializer_list of scalar entries.\n *\n * \\tparam Container The container type to construct.\n * \\tparam T The scalar type to use for the initializer_list.\n *\n * \\param list An initializer list of arbitrary size. The type of the entries is important!\n * If you pass a list of integers you will get a container filled with Vc::int_v objects.\n * If, instead, you want to have a container of Vc::float_v objects, be sure the include a\n * period (.) and the 'f' postfix in the literals. Alternatively, you can pass the\n * type as second template argument to makeContainer.\n *\n * \\return Returns a container of the requested class filled with the minimum number of SIMD\n * vectors to hold the values in the initializer list.\n * If the number of values in \\p list does not match the number of values in the\n * returned container object, the remaining values in the returned object will be\n * zero-initialized.\n *\n * Example:\n * \\code\n * auto data = Vc::makeContainer>({ 1.f, 2.f, 3.f, 4.f, 5.f });\n * // data.size() == 5 if float_v::Size == 1 (i.e. Vc_IMPL=Scalar)\n * // data.size() == 2 if float_v::Size == 4 (i.e. Vc_IMPL=SSE)\n * // data.size() == 1 if float_v::Size == 8 (i.e. Vc_IMPL=AVX)\n * \\endcode\n */\n template\n constexpr auto makeContainer(std::initializer_list list) -> decltype(make_container_helper::help(list))\n {\n return make_container_helper::help(list);\n }\n\n template\n constexpr auto make_container(std::initializer_list list) -> decltype(makeContainer(list))\n {\n return makeContainer(list);\n }\n\n} // namespace Vc\n\n#endif // VC_COMMON_MAKECONTAINER_H_\n" }, { "path": "3rdparty/Vc/Vc/common/make_unique.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MAKE_UNIQUE_H_\n#define VC_COMMON_MAKE_UNIQUE_H_\n\n#include \n#include \"malloc.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n\ntemplate struct Deleter\n{\n Vc_ALWAYS_INLINE void operator()(T *ptr) {\n ptr->~T();\n Vc::free(ptr);\n }\n};\n\ntemplate\ninline std::unique_ptr> make_unique(Args&&... args)\n{\n return std::unique_ptr>(new(Vc::malloc(1)) T(std::forward(args)...));\n}\n\n} // namespace Common\n} // namespace Vc\n\n#endif // VC_COMMON_MAKE_UNIQUE_H_\n" }, { "path": "3rdparty/Vc/Vc/common/malloc.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MALLOC_H_\n#define VC_COMMON_MALLOC_H_\n\n#ifndef Vc_VECTOR_DECLARED_\n#error \"Incorrect inclusion order. This header must be included from Vc/vector.h only.\"\n#endif\n\n#if defined _WIN32 || defined _WIN64\n#include \n#else\n#include \n#endif\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n\ntemplate static constexpr size_t nextMultipleOf(size_t value)\n{\n return (value % X) > 0 ? value + X - (value % X) : value;\n}\n\ntemplate Vc_INTRINSIC void *aligned_malloc(std::size_t n)\n{\n#ifdef __MIC__\n return _mm_malloc(nextMultipleOf(n), alignment);\n#elif defined(_WIN32)\n# ifdef __GNUC__\n return __mingw_aligned_malloc(nextMultipleOf(n), alignment);\n# else\n return _aligned_malloc(nextMultipleOf(n), alignment);\n# endif\n#else\n void *ptr = nullptr;\n if (0 == posix_memalign(&ptr, alignment < sizeof(void *) ? sizeof(void *) : alignment,\n nextMultipleOf(n))) {\n return ptr;\n }\n return ptr;\n#endif\n}\n\ntemplate Vc_ALWAYS_INLINE void *malloc(size_t n)\n{\n switch (A) {\n case Vc::AlignOnVector:\n return aligned_malloc(n);\n case Vc::AlignOnCacheline:\n // TODO: hardcoding 64 is not such a great idea\n return aligned_malloc<64>(n);\n case Vc::AlignOnPage:\n // TODO: hardcoding 4096 is not such a great idea\n return aligned_malloc<4096>(n);\n }\n return nullptr;\n}\n\nVc_ALWAYS_INLINE void free(void *p)\n{\n#ifdef __MIC__\n _mm_free(p);\n#elif defined(_WIN32)\n# ifdef __GNUC__\n return __mingw_aligned_free(p);\n# else\n return _aligned_free(p);\n# endif\n#else\n std::free(p);\n#endif\n}\n} // namespace Common\n\n/**\n * Allocates memory on the Heap with alignment and padding suitable for vectorized access.\n *\n * Memory that was allocated with this function must be released with Vc::free! Other methods might\n * work but are not portable.\n *\n * \\param n Specifies the number of objects the allocated memory must be able to store.\n * \\tparam T The type of the allocated memory. Note, that the constructor is not called.\n * \\tparam A Determines the alignment of the memory. See \\ref Vc::MallocAlignment.\n *\n * \\return Pointer to memory of the requested type, or 0 on error. The allocated memory is padded at\n * the end to be a multiple of the requested alignment \\p A. Thus if you request memory for 21\n * int objects, aligned via Vc::AlignOnCacheline, you can safely read a full cacheline until the\n * end of the array, without generating an out-of-bounds access. For a cacheline size of 64 Bytes\n * and an int size of 4 Bytes you would thus get an array of 128 Bytes to work with.\n *\n * \\warning\n * \\li The standard malloc function specifies the number of Bytes to allocate whereas this\n * function specifies the number of values, thus differing in a factor of sizeof(T).\n * \\li This function is mainly meant for use with builtin types. If you use a custom\n * type with a sizeof that is not a multiple of 2 the results might not be what you expect.\n * \\li The constructor of T is not called. You can make up for this:\n * \\code\n * SomeType *array = new(Vc::malloc(N)) SomeType[N];\n * \\endcode\n *\n * \\see Vc::free\n *\n * \\ingroup Utilities\n * \\headerfile memory.h \n */\ntemplate\nVc_ALWAYS_INLINE T *malloc(size_t n)\n{\n return static_cast(Common::malloc(n * sizeof(T)));\n}\n\n/**\n * Frees memory that was allocated with Vc::malloc.\n *\n * \\param p The pointer to the memory to be freed.\n *\n * \\tparam T The type of the allocated memory.\n *\n * \\warning The destructor of T is not called. If needed, you can call the destructor before calling\n * free:\n * \\code\n * for (int i = 0; i < N; ++i) {\n * p[i].~T();\n * }\n * Vc::free(p);\n * \\endcode\n *\n * \\ingroup Utilities\n * \\headerfile memory.h \n *\n * \\see Vc::malloc\n */\ntemplate\nVc_ALWAYS_INLINE void free(T *p)\n{\n Common::free(p);\n}\n} // namespace Vc\n\n#endif // VC_COMMON_MALLOC_H_\n" }, { "path": "3rdparty/Vc/Vc/common/mask.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MASK_H_\n#define VC_COMMON_MASK_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n/**\n * \\class Mask mask.h \n * \\ingroup Masks\n *\n * The main SIMD mask class.\n */\ntemplate > class Mask\n{\npublic:\n /**\n * Returns the number of boolean components (\\VSize{T}) in a mask of this type.\n *\n * The size of the mask. I.e. the number of boolean entries in the mask. Do not\n * make any assumptions about the size of masks.\n *\n * In addition, you can easily use if clauses that compare sizes. The compiler can\n * statically evaluate and fully optimize dead code away (very much like \\#ifdef, but\n * with syntax checking).\n *\n * \\returns The number of components (i.e. \\VSize{T}) objects of this mask type store\n * and manipulate.\n */\n static constexpr size_t size() { return VectorTraits::size(); }\n ///\\copydoc size\n ///\\deprecated Use Vc::Mask::size instead.\n static constexpr size_t Size = VectorTraits::size();\n\n /**\n * Specifies the alignment requirement for aligned load and store calls for objects of\n * this mask type.\n */\n static constexpr size_t MemoryAlignment = VectorTraits::maskMemoryAlignment();\n\n /// The ABI tag type of the current template instantiation.\n using abi = Abi;\n\n /**\n * The \\c EntryType of masks is always \\c bool, independent of \\c T.\n */\n using EntryType = bool;\n /// \\copydoc EntryType\n using value_type = EntryType;\n\n /// The reference wrapper type used for accessing individual mask components.\n using EntryReference = typename VectorTraits::EntryReference;\n /// \\copydoc EntryReference\n using value_reference = EntryReference;\n\n /**\n * The \\c VectorEntryType, in contrast to \\c EntryType, reveals information about the SIMD\n * implementation.\n * This type is useful for the \\c sizeof operator in generic functions.\n */\n using VectorEntryType = typename VectorTraits::VectorEntryType;\n\n /**\\internal\n * The \\c VectorType reveals the implementation-specific internal type used for the SIMD type.\n */\n using VectorType = typename VectorTraits::VectorType;\n /**\\internal\n * \\copydoc VectorType\n */\n using vector_type = VectorType;\n\n /*\n * The associated Vector type.\n */\n //using Vector = Vector;\n\n /// \\name Generators\n ///@{\n /**\n * Creates a new mask object initialized to zero/\\c false.\n *\n * \\returns A mask object with zero-initialized components.\n */\n Vc_INTRINSIC static Mask Zero();\n\n /**\n * Creates a mask object initialized to one/\\c true.\n *\n * \\returns A mask object with components initialized to \\c true.\n */\n Vc_INTRINSIC static Mask One();\n\n /// Generate a mask object from booleans returned from the function \\p gen.\n template static Vc_INTRINSIC Mask generate(G &&gen);\n ///@}\n\n /// \\name Compile-Time Constant Initialization\n ///@{\n /**\n * Construct a zero-initialized vector object.\n *\n * This constructor follows the behavior of the underlying \\c bool type in that the\n * expression `bool()` zero-initializes the object (to \\c false). On the other hand\n * the variable \\c x in `bool x;` is uninitialized.\n * Since, for class types, both expressions call the default constructor `Mask x`\n * must zero-initialize \\c x as well.\n */\n Vc_INTRINSIC Mask() = default;\n\n /// Zero-initialize the new mask object (\\c false).\n /// \\see Vc::Zero, Zero()\n Vc_INTRINSIC explicit Mask(VectorSpecialInitializerZero);\n\n /// Initialize the new mask object to one (\\c true).\n /// \\see Vc::One, One()\n Vc_INTRINSIC explicit Mask(VectorSpecialInitializerOne);\n ///@}\n\n /// \\name Conversion/Broadcast Constructors\n ///@{\n /**\n * Broadcast constructor.\n *\n * Set all components of the new mask object to \\p b.\n *\n * \\param b Determines the initial state of the mask.\n */\n Vc_INTRINSIC explicit Mask(bool b);\n\n /**\n * Implicit conversion from a compatible (equal \\VSize{T} on every platform) mask\n * object.\n *\n * \\param otherMask The mask to be converted.\n */\n template \n Vc_INTRINSIC Mask(U &&otherMask,\n Common::enable_if_mask_converts_implicitly = nullarg);\n\n#if Vc_IS_VERSION_1\n /**\n * Explicit conversion (static_cast) from a mask object that potentially has a\n * different \\VSize{T}.\n *\n * \\param otherMask The mask to be converted.\n *\n * \\internal This is implemented via simd_cast in scalar/simd_cast_caller.h\n */\n template \n Vc_DEPRECATED(\n \"use simd_cast instead of explicit type casting to convert between mask types\")\n Vc_INTRINSIC_L\n explicit Mask(U &&otherMask, Common::enable_if_mask_converts_explicitly =\n nullarg) Vc_INTRINSIC_R;\n ///@}\n#endif\n\n /**\n * \\name Loads & Stores\n */\n ///@{\n /**\n * Load constructor from an array of \\c bool.\n *\n * This constructor implements an explicit conversion from an array of booleans to a\n * mask object. It corresponds to a Vector load constructor.\n *\n * \\param mem A pointer to the start of the array of booleans.\n * \\see Mask(const bool *, Flags), load(const bool *)\n */\n Vc_ALWAYS_INLINE explicit Mask(const bool *mem);\n /**\n * Overload of the above with a load/store flag argument.\n *\n * \\param mem A pointer to the start of the array of booleans.\n * \\param flags Choose a combination of flags such as Vc::Aligned, Vc::Streaming,\n * Vc::Unaligned, Vc::PrefetchDefault, ...\n * \\see load(const bool *, Flags)\n */\n template Vc_ALWAYS_INLINE explicit Mask(const bool *mem, Flags flags);\n\n /**\n * Load the components of the mask from an array of \\c bool.\n *\n * \\param mem A pointer to the start of the array of booleans.\n * \\see load(const bool *, Flags), Mask(const bool *)\n */\n Vc_ALWAYS_INLINE void load(const bool *mem);\n /**\n * Overload of the above with a load/store flag argument.\n *\n * \\param mem A pointer to the start of the array of booleans.\n * \\param flags Choose a combination of flags such as Vc::Aligned, Vc::Streaming,\n * Vc::Unaligned, Vc::PrefetchDefault, ...\n * \\see Mask(const bool *, Flags)\n */\n template Vc_ALWAYS_INLINE void load(const bool *mem, Flags flags);\n\n /**\n * Store the values of the mask to an array of \\c bool.\n *\n * \\param mem A pointer to the start of the array of booleans.\n * \\see store(bool *, Flags)\n */\n Vc_ALWAYS_INLINE void store(bool *mem) const;\n /**\n * Overload of the above with a load/store flag argument.\n *\n * \\param mem A pointer to the start of the array of booleans.\n * \\param flags Choose a combination of flags such as Vc::Aligned, Vc::Streaming,\n * Vc::Unaligned, Vc::PrefetchDefault, ...\n */\n template Vc_ALWAYS_INLINE void store(bool *mem, Flags flags) const;\n ///@}\n\n /// \\name Comparison Operators\n ///@{\n /**\n * Returns whether the two masks are equal in all components.\n *\n * \\param mask The other mask to compare against.\n * \\returns A scalar boolean value that says whether all components of the two masks\n * are equal.\n *\n * \\note If you expected a behavior similar to the compare operator of Vc::Vector,\n * consider that the bitwise operators already implement such functionality. There is\n * little use, typically, in having `a == b` return the same as `a ^ b`. In general,\n * it is more useful to query `all_of(a ^ b)` which is the same as this equality\n * operator.\n */\n Vc_ALWAYS_INLINE bool operator==(const Mask &mask) const;\n\n /**\n * Returns whether the two masks are different in at least one component.\n *\n * \\param mask The other mask to compare against.\n * \\returns A scalar boolean value that says whether at least one component of the two masks is different.\n *\n * \\note `(a == b) == !(a != b)` holds\n * \\see Mask::operator==(const Mask &)\n */\n Vc_ALWAYS_INLINE bool operator!=(const Mask &mask) const;\n ///@}\n\n /**\n * \\name Logical and Binary Operators\n *\n * \\brief Component-wise logical/binary operations on mask objects.\n *\n * The effect of logical and binary \\c AND and \\c OR is equivalent for mask types (as\n * it is for \\c bool).\n */\n ///@{\n\n /// Returns the component-wise application of a logical \\c AND to \\p mask.\n Vc_ALWAYS_INLINE Mask operator&&(const Mask &mask) const;\n /// Returns the component-wise application of a binary \\c AND to \\p mask.\n Vc_ALWAYS_INLINE Mask operator&(const Mask &mask) const;\n /// Returns the component-wise application of a logical \\c OR to \\p mask.\n Vc_ALWAYS_INLINE Mask operator||(const Mask &mask) const;\n /// Returns the component-wise application of a binary \\c OR to \\p mask.\n Vc_ALWAYS_INLINE Mask operator|(const Mask &mask) const;\n /// Returns the component-wise application of a binary \\c XOR to \\p mask.\n Vc_ALWAYS_INLINE Mask operator^(const Mask &mask) const;\n /// Returns a mask with inverted components.\n Vc_ALWAYS_INLINE Mask operator!() const;\n\n /// Modifies the mask using an \\c AND operation with \\p mask.\n Vc_ALWAYS_INLINE Mask &operator&=(const Mask &mask);\n /// Modifies the mask using an \\c OR operation with \\p mask.\n Vc_ALWAYS_INLINE Mask &operator|=(const Mask &mask);\n /// Modifies the mask using an \\c XOR operation with \\p mask.\n Vc_ALWAYS_INLINE Mask &operator^=(const Mask &mask);\n ///@}\n\n /**\n * \\name Reductions\n *\n * \\see any_of, all_of, none_of, some_of\n */\n ///@{\n\n /// Returns a logical \\c AND of all components.\n Vc_ALWAYS_INLINE bool isFull() const;\n /// Returns a logical \\c OR of all components.\n Vc_ALWAYS_INLINE bool isNotEmpty() const;\n /// Returns \\c true if components are \\c false, \\c false otherwise.\n Vc_ALWAYS_INLINE bool isEmpty() const;\n /// Returns `!isFull() && !isEmpty()`.\n Vc_ALWAYS_INLINE bool isMix() const;\n ///@}\n\n /**\\internal\n * \\name Internal Data Access\n */\n ///@{\n Vc_ALWAYS_INLINE bool data() const;\n Vc_ALWAYS_INLINE bool dataI() const;\n Vc_ALWAYS_INLINE bool dataD() const;\n ///@}\n\n /// \\name Scalar Subscript Operators\n ///@{\n /**\n * Lvalue-reference-like access to mask entries.\n *\n * \\param index Determines the boolean to be accessed.\n * \\return a temporary proxy object referencing the \\p index th entry of the mask.\n *\n * \\warning This operator does not return an lvalue reference (to \\c bool), but rather\n * a temporary (rvalue) object that mimics an lvalue reference (as much as is possible\n * with C++11/14).\n */\n Vc_ALWAYS_INLINE EntryReference operator[](size_t index);\n\n /**\n * Read-only access to mask entries.\n *\n * \\param index Determines the boolean to be accessed.\n * \\return The \\p index th entry of the mask as a \\c bool (rvalue).\n *\n * \\warning This operator does not return an lvalue reference (to `const bool`), but\n * rather a temporary (rvalue) \\c bool.\n */\n Vc_ALWAYS_INLINE EntryType operator[](size_t index) const;\n ///@}\n\n /// Returns how many components of the mask are \\c true.\n Vc_ALWAYS_INLINE int count() const;\n\n /**\n * Returns the index of the first one in the mask.\n *\n * \\returns the index of the first component that is \\c true.\n *\n * \\warning The return value is undefined if the mask is empty.\n *\n * Thus, unless `none_of(mask)`, `mask[mask.firstOne()] == true` holds and `mask[i] ==\n * false` for all `i < mask.firstOne()`.\n */\n Vc_ALWAYS_INLINE int firstOne() const;\n\n /**\n * Convert the boolean components of the mask into bits of an integer.\n *\n * \\return An \\c int where each bit corresponds to the boolean value in the mask.\n *\n * For example, the mask `[true, false, false, true]` results in a `9` (in binary: `1001`).\n */\n Vc_ALWAYS_INLINE int toInt() const;\n\n /// Returns a mask with components shifted by \\p amount places.\n Vc_INTRINSIC Vc_PURE Mask shifted(int amount) const;\n\n Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(Mask));\n\nprivate:\n VectorType d;\n};\n\n/**\n * \\ingroup Utilities\n *\n * \\name Boolean Reductions\n */\n//@{\n/** \\ingroup Utilities\n * Returns whether all entries in the mask \\p m are \\c true.\n */\ntemplate constexpr bool all_of(const Mask &m) { return m.isFull(); }\n/** \\ingroup Utilities\n * Returns \\p b\n */\nconstexpr bool all_of(bool b) { return b; }\n\n/** \\ingroup Utilities\n * Returns whether at least one entry in the mask \\p m is \\c true.\n */\ntemplate constexpr bool any_of(const Mask &m) { return m.isNotEmpty(); }\n/** \\ingroup Utilities\n * Returns \\p b\n */\nconstexpr bool any_of(bool b) { return b; }\n\n/** \\ingroup Utilities\n * Returns whether all entries in the mask \\p m are \\c false.\n */\ntemplate constexpr bool none_of(const Mask &m) { return m.isEmpty(); }\n/** \\ingroup Utilities\n * Returns \\p !b\n */\nconstexpr bool none_of(bool b) { return !b; }\n\n/** \\ingroup Utilities\n * Returns whether at least one entry in \\p m is \\c true and at least one entry in \\p m is \\c\n * false.\n */\ntemplate constexpr bool some_of(const Mask &m) { return m.isMix(); }\n/** \\ingroup Utilities\n * Returns \\c false\n */\nconstexpr bool some_of(bool) { return false; }\n//@}\n} // namespace Vc\n\n#endif // VC_COMMON_MASK_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/maskbool.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MASKENTRY_H_\n#define VC_COMMON_MASKENTRY_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n\nnamespace\n{\n template struct MaskBoolStorage;\n // the following for typedefs must use std::intN_t and NOT! Vc::intN_t. The latter\n // segfaults ICC 15.0.3.\n template<> struct MaskBoolStorage<1> { typedef std::int8_t type; };\n template<> struct MaskBoolStorage<2> { typedef std::int16_t type; };\n template<> struct MaskBoolStorage<4> { typedef std::int32_t type; };\n template<> struct MaskBoolStorage<8> { typedef std::int64_t type; };\n} // anonymous namespace\n\ntemplate class MaskBool\n{\n typedef typename MaskBoolStorage::type storage_type Vc_MAY_ALIAS;\n storage_type data;\npublic:\n constexpr MaskBool(bool x) noexcept : data(x ? -1 : 0) {}\n Vc_ALWAYS_INLINE MaskBool &operator=(bool x) noexcept { data = x ? -1 : 0; return *this; }\n template ::value &&\n std::is_fundamental::value)>>\n Vc_ALWAYS_INLINE MaskBool &operator=(T x) noexcept\n {\n data = reinterpret_cast(x);\n return *this;\n }\n\n Vc_ALWAYS_INLINE MaskBool(const MaskBool &) noexcept = default;\n Vc_ALWAYS_INLINE MaskBool &operator=(const MaskBool &) noexcept = default;\n\n template ::value ||\n (std::is_fundamental::value &&\n sizeof(storage_type) == sizeof(T)))>>\n constexpr operator T() const noexcept\n {\n return std::is_same::value ? T((data & 1) != 0) : aliasing_cast(data);\n }\n} Vc_MAY_ALIAS;\n\ntemplate ::value &&std::is_convertible::value,\n int>::type = 0>\nconstexpr bool operator==(A &&a, B &&b)\n{\n return static_cast(a) == static_cast(b);\n}\ntemplate ::value &&std::is_convertible::value,\n int>::type = 0>\nconstexpr bool operator!=(A &&a, B &&b)\n{\n return static_cast(a) != static_cast(b);\n}\n\n} // namespace Common\n} // namespace Vc\n\n#endif // VC_COMMON_MASKENTRY_H_\n" }, { "path": "3rdparty/Vc/Vc/common/math.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MATH_H_\n#define VC_COMMON_MATH_H_\n\n#define Vc_COMMON_MATH_H_INTERNAL 1\n\n#include \"trigonometric.h\"\n\n#include \"const.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n// TODO, not vectorized:\ntemplate \nSimdArray::size()> fpclassify(const Vector &x)\n{\n return SimdArray::size()>(\n [&](std::size_t i) { return std::fpclassify(x[i]); });\n}\ntemplate SimdArray fpclassify(const SimdArray &x)\n{\n return SimdArray([&](std::size_t i) { return std::fpclassify(x[i]); });\n}\n\n#ifdef Vc_IMPL_SSE\n// for SSE, AVX, and AVX2\n#include \"logarithm.h\"\n#include \"exponential.h\"\n#ifdef Vc_IMPL_AVX\ninline AVX::double_v exp(AVX::double_v _x)\n{\n AVX::Vector x = _x;\n typedef AVX::Vector V;\n typedef V::Mask M;\n typedef AVX::Const C;\n\n const M overflow = x > Vc::Detail::doubleConstant< 1, 0x0006232bdd7abcd2ull, 9>(); // max log\n const M underflow = x < Vc::Detail::doubleConstant<-1, 0x0006232bdd7abcd2ull, 9>(); // min log\n\n V px = floor(C::log2_e() * x + 0.5);\n __m128i tmp = _mm256_cvttpd_epi32(px.data());\n const SimdArray n = SSE::int_v{tmp};\n x -= px * C::ln2_large(); //Vc::Detail::doubleConstant<1, 0x00062e4000000000ull, -1>(); // ln2\n x -= px * C::ln2_small(); //Vc::Detail::doubleConstant<1, 0x0007f7d1cf79abcaull, -20>(); // ln2\n\n const double P[] = {\n Vc::Detail::doubleConstant<1, 0x000089cdd5e44be8ull, -13>(),\n Vc::Detail::doubleConstant<1, 0x000f06d10cca2c7eull, -6>(),\n Vc::Detail::doubleConstant<1, 0x0000000000000000ull, 0>()\n };\n const double Q[] = {\n Vc::Detail::doubleConstant<1, 0x00092eb6bc365fa0ull, -19>(),\n Vc::Detail::doubleConstant<1, 0x0004ae39b508b6c0ull, -9>(),\n Vc::Detail::doubleConstant<1, 0x000d17099887e074ull, -3>(),\n Vc::Detail::doubleConstant<1, 0x0000000000000000ull, 1>()\n };\n const V x2 = x * x;\n px = x * ((P[0] * x2 + P[1]) * x2 + P[2]);\n x = px / ((((Q[0] * x2 + Q[1]) * x2 + Q[2]) * x2 + Q[3]) - px);\n x = V::One() + 2.0 * x;\n\n x = ldexp(x, n); // == x * 2ⁿ\n\n x(overflow) = std::numeric_limits::infinity();\n x.setZero(underflow);\n\n return x;\n }\n#endif // Vc_IMPL_AVX\n\ninline SSE::double_v exp(SSE::double_v::AsArg _x) {\n SSE::Vector x = _x;\n typedef SSE::Vector V;\n typedef V::Mask M;\n typedef SSE::Const C;\n\n const M overflow = x > Vc::Detail::doubleConstant< 1, 0x0006232bdd7abcd2ull, 9>(); // max log\n const M underflow = x < Vc::Detail::doubleConstant<-1, 0x0006232bdd7abcd2ull, 9>(); // min log\n\n V px = floor(C::log2_e() * x + 0.5);\n SimdArray n;\n _mm_storel_epi64(reinterpret_cast<__m128i *>(&n), _mm_cvttpd_epi32(px.data()));\n x -= px * C::ln2_large(); //Vc::Detail::doubleConstant<1, 0x00062e4000000000ull, -1>(); // ln2\n x -= px * C::ln2_small(); //Vc::Detail::doubleConstant<1, 0x0007f7d1cf79abcaull, -20>(); // ln2\n\n const double P[] = {\n Vc::Detail::doubleConstant<1, 0x000089cdd5e44be8ull, -13>(),\n Vc::Detail::doubleConstant<1, 0x000f06d10cca2c7eull, -6>(),\n Vc::Detail::doubleConstant<1, 0x0000000000000000ull, 0>()\n };\n const double Q[] = {\n Vc::Detail::doubleConstant<1, 0x00092eb6bc365fa0ull, -19>(),\n Vc::Detail::doubleConstant<1, 0x0004ae39b508b6c0ull, -9>(),\n Vc::Detail::doubleConstant<1, 0x000d17099887e074ull, -3>(),\n Vc::Detail::doubleConstant<1, 0x0000000000000000ull, 1>()\n };\n const V x2 = x * x;\n px = x * ((P[0] * x2 + P[1]) * x2 + P[2]);\n x = px / ((((Q[0] * x2 + Q[1]) * x2 + Q[2]) * x2 + Q[3]) - px);\n x = V::One() + 2.0 * x;\n\n x = ldexp(x, n); // == x * 2ⁿ\n\n x(overflow) = std::numeric_limits::infinity();\n x.setZero(underflow);\n\n return x;\n }\n\n#endif\n} // namespace Vc\n\n#undef Vc_COMMON_MATH_H_INTERNAL\n\n#endif // VC_COMMON_MATH_H_\n" }, { "path": "3rdparty/Vc/Vc/common/memory.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MEMORY_H_\n#define VC_COMMON_MEMORY_H_\n\n#include \"memorybase.h\"\n#include \n#include \n#include \n#include \n#include \n#include \"memoryfwd.h\"\n#include \"malloc.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\ntemplate struct _MemorySizeCalculation\n{\n enum AlignmentCalculations {\n Alignment = V::Size,\n AlignmentMask = Alignment - 1,\n MaskedSize = Size & AlignmentMask,\n Padding = Alignment - MaskedSize,\n PaddedSize = MaskedSize == 0 ? Size : Size + Padding\n };\n};\n\n/**\n * \\ingroup Containers\n * \\headerfile memory.h \n *\n * A helper class for fixed-size two-dimensional arrays.\n *\n * \\param V The vector type you want to operate on. (e.g. float_v or uint_v)\n * \\param Size1 Number of rows\n * \\param Size2 Number of columns\n */\ntemplate \nclass Memory : public MemoryBase, 2,\n Memory>\n{\npublic:\n typedef typename V::EntryType EntryType;\n\nprivate:\n using RowMemory = Memory;\n typedef MemoryBase, 2, RowMemory> Base;\n friend class MemoryBase, 2, RowMemory>;\n friend class MemoryDimensionBase, 2,\n RowMemory>;\n enum : size_t {\n Alignment = V::MemoryAlignment,\n PaddedSize2 = _MemorySizeCalculation::PaddedSize\n };\n alignas(static_cast(Alignment)) // GCC complains about 'is not an\n // integer constant' unless the\n // static_cast is present\n RowMemory m_mem[Size1];\n\n public:\n using Base::vector;\n enum Constants {\n RowCount = Size1,\n VectorsCount = PaddedSize2 / V::Size\n };\n\n Memory() = default;\n\n /**\n * \\return the number of rows in the array.\n *\n * \\note This function can be eliminated by an optimizing compiler.\n */\n static constexpr size_t rowsCount() { return RowCount; }\n /**\n * \\return the number of scalar entries in the whole array.\n *\n * \\warning Do not use this function for scalar iteration over the array since there will be\n * padding between rows if \\c Size2 is not divisible by \\c V::Size.\n *\n * \\note This function can be optimized into a compile-time constant.\n */\n static constexpr size_t entriesCount() { return Size1 * Size2; }\n /**\n * \\return the number of vectors in the whole array.\n *\n * \\note This function can be optimized into a compile-time constant.\n */\n static constexpr size_t vectorsCount() { return VectorsCount * Size1; }\n\n /**\n * Copies the data from a different object.\n *\n * \\param rhs The object to copy the data from.\n *\n * \\return reference to the modified Memory object.\n *\n * \\note Both objects must have the exact same vectorsCount().\n */\n template\n Vc_ALWAYS_INLINE Memory &operator=(const MemoryBase &rhs) {\n assert(vectorsCount() == rhs.vectorsCount());\n Detail::copyVectors(*this, rhs);\n return *this;\n }\n\n Vc_ALWAYS_INLINE Memory &operator=(const Memory &rhs) {\n Detail::copyVectors(*this, rhs);\n return *this;\n }\n\n /**\n * Initialize all data with the given vector.\n *\n * \\param v This vector will be used to initialize the memory.\n *\n * \\return reference to the modified Memory object.\n */\n inline Memory &operator=(const V &v) {\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) = v;\n }\n return *this;\n }\n};\n\n /**\n * A helper class to simplify usage of correctly aligned and padded memory, allowing both vector and\n * scalar access.\n *\n * Example:\n * \\code\n Vc::Memory array;\n\n // scalar access:\n for (size_t i = 0; i < array.entriesCount(); ++i) {\n int x = array[i]; // read\n array[i] = x; // write\n }\n // more explicit alternative:\n for (size_t i = 0; i < array.entriesCount(); ++i) {\n int x = array.scalar(i); // read\n array.scalar(i) = x; // write\n }\n\n // vector access:\n for (size_t i = 0; i < array.vectorsCount(); ++i) {\n int_v x = array.vector(i); // read\n array.vector(i) = x; // write\n }\n * \\endcode\n * This code allocates a small array and implements three equivalent loops (that do nothing useful).\n * The loops show how scalar and vector read/write access is best implemented.\n *\n * Since the size of 11 is not a multiple of int_v::Size (unless you use the\n * scalar Vc implementation) the last write access of the vector loop would normally be out of\n * bounds. But the Memory class automatically pads the memory such that the whole array can be\n * accessed with correctly aligned memory addresses.\n *\n * \\param V The vector type you want to operate on. (e.g. float_v or uint_v)\n * \\param Size The number of entries of the scalar base type the memory should hold. This\n * is thus the same number as you would use for a normal C array (e.g. float mem[11] becomes\n * Memory mem).\n *\n * \\see Memory\n *\n * \\ingroup Containers\n * \\headerfile memory.h \n */\ntemplate \nclass Memory :\n public MemoryBase, 1, void>\n {\n public:\n typedef typename V::EntryType EntryType;\n private:\n typedef MemoryBase, 1, void> Base;\n friend class MemoryBase, 1, void>;\n friend class MemoryDimensionBase, 1, void>;\n enum : size_t {\n Alignment = V::MemoryAlignment, // in Bytes\n MaskedSize = Size & (V::Size - 1), // the fraction of Size that exceeds\n // an integral multiple of V::Size\n Padding = V::Size - MaskedSize,\n PaddedSize = MaskedSize == 0 ? Size : Size + Padding\n };\n alignas(static_cast(Alignment)) // GCC complains about 'is not an\n // integer constant' unless the\n // static_cast is present\n EntryType m_mem[PaddedSize];\n\n public:\n using Base::vector;\n enum Constants {\n EntriesCount = Size,\n VectorsCount = PaddedSize / V::Size\n };\n\n Memory()\n {\n if (InitPadding) {\n Base::lastVector() = V::Zero();\n }\n }\n\n Memory(std::initializer_list init)\n {\n Vc_ASSERT(init.size() <= Size);\n Base::lastVector() = V::Zero();\n std::copy(init.begin(), init.end(), &m_mem[0]);\n }\n\n /**\n * Wrap existing data with the Memory convenience class.\n *\n * This function returns a \\em reference to a Memory object that you must\n * capture to avoid a copy of the whole data:\n * \\code\n * Memory &m = Memory::fromRawData(someAlignedPointerToFloat)\n * \\endcode\n *\n * \\param ptr An aligned pointer to memory of type \\p V::EntryType (e.g. \\c float for\n * Vc::float_v).\n * \\return A Memory object placed at the given location in memory.\n *\n * \\warning The pointer \\p ptr passed to this function must be aligned according to the\n * alignment restrictions of \\p V.\n * \\warning The size of the accessible memory must match \\p Size. This includes the\n * required padding at the end to allow the last entries to be accessed via vectors. If\n * you know what you are doing you might violate this constraint.\n * \\warning It is your responsibility to ensure that the memory is released correctly\n * (not too early/not leaked). This function simply adds convenience functions to \\em\n * access the memory.\n */\n static Vc_ALWAYS_INLINE Vc_CONST Memory &fromRawData(EntryType *ptr)\n {\n // DANGER! This placement new has to use the right address. If the compiler decides\n // RowMemory requires padding before the actual data then the address has to be adjusted\n // accordingly\n char *addr = reinterpret_cast(ptr);\n typedef Memory MM;\n addr -= offsetof(MM, m_mem);\n return *new(addr) MM;\n }\n\n /**\n * \\return the number of scalar entries in the whole array.\n *\n * \\note This function can be optimized into a compile-time constant.\n */\n static constexpr size_t entriesCount() { return EntriesCount; }\n\n /**\n * \\return the number of vectors in the whole array.\n *\n * \\note This function can be optimized into a compile-time constant.\n */\n static constexpr size_t vectorsCount() { return VectorsCount; }\n\n inline Memory(const Memory &rhs)\n {\n Detail::copyVectors(*this, rhs);\n }\n\n template inline Memory(const Memory &rhs)\n {\n assert(vectorsCount() == rhs.vectorsCount());\n Detail::copyVectors(*this, rhs);\n }\n\n inline Memory &operator=(const Memory &rhs)\n {\n Detail::copyVectors(*this, rhs);\n return *this;\n }\n\n template inline Memory &operator=(const Memory &rhs)\n {\n assert(vectorsCount() == rhs.vectorsCount());\n Detail::copyVectors(*this, rhs);\n return *this;\n }\n\n Vc_ALWAYS_INLINE Memory &operator=(const EntryType *rhs) {\n std::memcpy(m_mem, rhs, entriesCount() * sizeof(EntryType));\n return *this;\n }\n inline Memory &operator=(const V &v) {\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) = v;\n }\n return *this;\n }\n };\n\n /**\n * A helper class that is very similar to Memory but with dynamically allocated memory and\n * thus dynamic size.\n *\n * Example:\n * \\code\n size_t size = 11;\n Vc::Memory array(size);\n\n // scalar access:\n for (size_t i = 0; i < array.entriesCount(); ++i) {\n array[i] = i;\n }\n\n // vector access:\n for (size_t i = 0; i < array.vectorsCount(); ++i) {\n array.vector(i) = int_v::IndexesFromZero() + i * int_v::Size;\n }\n * \\endcode\n * This code allocates a small array with 11 scalar entries\n * and implements two equivalent loops that initialize the memory.\n * The scalar loop writes each individual int. The vectorized loop writes int_v::Size values to\n * memory per iteration. Since the size of 11 is not a multiple of int_v::Size (unless you use the\n * scalar Vc implementation) the last write access of the vector loop would normally be out of\n * bounds. But the Memory class automatically pads the memory such that the whole array can be\n * accessed with correctly aligned memory addresses.\n * (Note: the scalar loop can be auto-vectorized, except for the last three assignments.)\n *\n * \\note The internal data pointer is not declared with the \\c __restrict__ keyword. Therefore\n * modifying memory of V::EntryType will require the compiler to assume aliasing. If you want to use\n * the \\c __restrict__ keyword you need to use a standard pointer to memory and do the vector\n * address calculation and loads and stores manually.\n *\n * \\param V The vector type you want to operate on. (e.g. float_v or uint_v)\n *\n * \\see Memory\n *\n * \\ingroup Containers\n * \\headerfile memory.h \n */\n template class Memory : public MemoryBase, 1, void>\n {\n public:\n typedef typename V::EntryType EntryType;\n private:\n typedef MemoryBase, 1, void> Base;\n friend class MemoryBase, 1, void>;\n friend class MemoryDimensionBase, 1, void>;\n enum InternalConstants {\n Alignment = V::Size,\n AlignmentMask = Alignment - 1\n };\n size_t m_entriesCount;\n size_t m_vectorsCount;\n EntryType *m_mem;\n size_t calcPaddedEntriesCount(size_t x)\n {\n size_t masked = x & AlignmentMask;\n return (masked == 0 ? x : x + (Alignment - masked));\n }\n public:\n using Base::vector;\n\n /**\n * Allocate enough memory to access \\p size values of type \\p V::EntryType.\n *\n * The allocated memory is aligned and padded correctly for fully vectorized access.\n *\n * \\param size Determines how many scalar values will fit into the allocated memory.\n */\n Vc_ALWAYS_INLINE Memory(size_t size)\n : m_entriesCount(size),\n m_vectorsCount(calcPaddedEntriesCount(m_entriesCount)),\n m_mem(Vc::malloc(m_vectorsCount))\n {\n m_vectorsCount /= V::Size;\n Base::lastVector() = V::Zero();\n }\n\n /**\n * Copy the memory into a new memory area.\n *\n * The allocated memory is aligned and padded correctly for fully vectorized access.\n *\n * \\param rhs The Memory object to copy from.\n */\n template\n Vc_ALWAYS_INLINE Memory(const MemoryBase &rhs)\n : m_entriesCount(rhs.entriesCount()),\n m_vectorsCount(rhs.vectorsCount()),\n m_mem(Vc::malloc(m_vectorsCount * V::Size))\n {\n Detail::copyVectors(*this, rhs);\n }\n\n /**\n * Overload of the above function.\n *\n * (Because C++ would otherwise not use the templated cctor and use a default-constructed cctor instead.)\n *\n * \\param rhs The Memory object to copy from.\n */\n Vc_ALWAYS_INLINE Memory(const Memory &rhs)\n : m_entriesCount(rhs.entriesCount()),\n m_vectorsCount(rhs.vectorsCount()),\n m_mem(Vc::malloc(m_vectorsCount * V::Size))\n {\n Detail::copyVectors(*this, rhs);\n }\n\n /**\n * Frees the memory which was allocated in the constructor.\n */\n Vc_ALWAYS_INLINE ~Memory()\n {\n Vc::free(m_mem);\n }\n\n /**\n * Swap the contents and size information of two Memory objects.\n *\n * \\param rhs The other Memory object to swap.\n */\n inline void swap(Memory &rhs) {\n std::swap(m_mem, rhs.m_mem);\n std::swap(m_entriesCount, rhs.m_entriesCount);\n std::swap(m_vectorsCount, rhs.m_vectorsCount);\n }\n\n /**\n * \\return the number of scalar entries in the whole array.\n */\n Vc_ALWAYS_INLINE Vc_PURE size_t entriesCount() const { return m_entriesCount; }\n\n /**\n * \\return the number of vectors in the whole array.\n */\n Vc_ALWAYS_INLINE Vc_PURE size_t vectorsCount() const { return m_vectorsCount; }\n\n /**\n * Overwrite all entries with the values stored in \\p rhs.\n *\n * \\param rhs The object to copy the data from.\n *\n * \\return reference to the modified Memory object.\n *\n * \\note this function requires the vectorsCount() of both Memory objects to be equal.\n */\n template\n Vc_ALWAYS_INLINE Memory &operator=(const MemoryBase &rhs) {\n assert(vectorsCount() == rhs.vectorsCount());\n Detail::copyVectors(*this, rhs);\n return *this;\n }\n\n Vc_ALWAYS_INLINE Memory &operator=(const Memory &rhs) {\n assert(vectorsCount() == rhs.vectorsCount());\n Detail::copyVectors(*this, rhs);\n return *this;\n }\n\n /**\n * Overwrite all entries with the values stored in the memory at \\p rhs.\n *\n * \\param rhs The array to copy the data from.\n *\n * \\return reference to the modified Memory object.\n *\n * \\note this function requires that there are entriesCount() many values accessible from \\p rhs.\n */\n Vc_ALWAYS_INLINE Memory &operator=(const EntryType *rhs) {\n std::memcpy(m_mem, rhs, entriesCount() * sizeof(EntryType));\n return *this;\n }\n};\n\n/**\n * Prefetch the cacheline containing \\p addr for a single read access.\n *\n * This prefetch completely bypasses the cache, not evicting any other data.\n *\n * \\param addr The cacheline containing \\p addr will be prefetched.\n *\n * \\ingroup Utilities\n * \\headerfile memory.h \n */\nVc_ALWAYS_INLINE void prefetchForOneRead(const void *addr)\n{\n Vc::Detail::prefetchForOneRead(addr, VectorAbi::Best());\n}\n\n/**\n * Prefetch the cacheline containing \\p addr for modification.\n *\n * This prefetch evicts data from the cache. So use it only for data you really will use. When the\n * target system supports it the cacheline will be marked as modified while prefetching, saving work\n * later on.\n *\n * \\param addr The cacheline containing \\p addr will be prefetched.\n *\n * \\ingroup Utilities\n * \\headerfile memory.h \n */\nVc_ALWAYS_INLINE void prefetchForModify(const void *addr)\n{\n Vc::Detail::prefetchForModify(addr, VectorAbi::Best());\n}\n\n/**\n * Prefetch the cacheline containing \\p addr to L1 cache.\n *\n * This prefetch evicts data from the cache. So use it only for data you really will use.\n *\n * \\param addr The cacheline containing \\p addr will be prefetched.\n *\n * \\ingroup Utilities\n * \\headerfile memory.h \n */\nVc_ALWAYS_INLINE void prefetchClose(const void *addr)\n{\n Vc::Detail::prefetchClose(addr, VectorAbi::Best());\n}\n\n/**\n * Prefetch the cacheline containing \\p addr to L2 cache.\n *\n * This prefetch evicts data from the cache. So use it only for data you really will use.\n *\n * \\param addr The cacheline containing \\p addr will be prefetched.\n *\n * \\ingroup Utilities\n * \\headerfile memory.h \n */\nVc_ALWAYS_INLINE void prefetchMid(const void *addr)\n{\n Vc::Detail::prefetchMid(addr, VectorAbi::Best());\n}\n\n/**\n * Prefetch the cacheline containing \\p addr to L3 cache.\n *\n * This prefetch evicts data from the cache. So use it only for data you really will use.\n *\n * \\param addr The cacheline containing \\p addr will be prefetched.\n *\n * \\ingroup Utilities\n * \\headerfile memory.h \n */\nVc_ALWAYS_INLINE void prefetchFar(const void *addr)\n{\n Vc::Detail::prefetchFar(addr, VectorAbi::Best());\n}\n} // namespace Common\n\nusing Common::Memory;\nusing Common::prefetchForOneRead;\nusing Common::prefetchForModify;\nusing Common::prefetchClose;\nusing Common::prefetchMid;\nusing Common::prefetchFar;\n} // namespace Vc\n\nnamespace std\n{\n template Vc_ALWAYS_INLINE void swap(Vc::Memory &a, Vc::Memory &b) { a.swap(b); }\n} // namespace std\n\n#endif // VC_COMMON_MEMORY_H_\n" }, { "path": "3rdparty/Vc/Vc/common/memorybase.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2009-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MEMORYBASE_H_\n#define VC_COMMON_MEMORYBASE_H_\n\n#include \n#include \n#include \n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n\n#define Vc_MEM_OPERATOR_EQ(op) \\\n template \\\n Vc_ALWAYS_INLINE enable_if_mutable operator op##=(const T &x) { \\\n const V v = value() op x; \\\n v.store(&m_data[0], Flags()); \\\n return *this; \\\n }\n/*dox{{{*/\n/**\n * Helper class for the Memory::vector(size_t) class of functions.\n *\n * You will never need to directly make use of this class. It is an implementation detail of the\n * Memory API.\n *\n * \\headerfile memorybase.h \n *//*}}}*/\ntemplate class MemoryVector/*{{{*/\n{\n typedef typename std::remove_cv<_V>::type V;\n\n template using enable_if_mutable =\n typename std::enable_if::value && !std::is_const<_V>::value, R>::type;\n\n using EntryType =\n typename std::conditional::value, const typename V::EntryType,\n typename V::EntryType>::type;\n typedef typename V::Mask Mask;\n\n EntryType m_data[V::Size];\n\npublic:\n // It is important that neither initialization nor cleanup is done as MemoryVector aliases\n // other memory\n Vc_INTRINSIC MemoryVector() = default;\n\n // disable copies because this type is supposed to alias the data in a Memory object,\n // nothing else\n MemoryVector(const MemoryVector &) = delete;\n MemoryVector(MemoryVector &&) = delete;\n // Do not disable MemoryVector &operator=(const MemoryVector &) = delete; because it is\n // covered nicely by the operator= below.\n\n //! \\internal\n Vc_ALWAYS_INLINE Vc_PURE V value() const { return V(&m_data[0], Flags()); }\n\n /**\n * Cast to \\p V operator.\n *\n * This function allows to assign this object to any object of type \\p V.\n */\n Vc_ALWAYS_INLINE Vc_PURE operator V() const { return value(); }\n\n template\n Vc_ALWAYS_INLINE enable_if_mutable operator=(const T &x) {\n V v;\n v = x;\n v.store(&m_data[0], Flags());\n return *this;\n }\n\n Vc_ALL_BINARY(Vc_MEM_OPERATOR_EQ);\n Vc_ALL_ARITHMETICS(Vc_MEM_OPERATOR_EQ);\n\n Vc_ALWAYS_INLINE EntryType &operator[](size_t i) { return m_data[i]; }\n Vc_ALWAYS_INLINE const EntryType &operator[](size_t i) const { return m_data[i]; }\n};\n\ntemplate class MemoryVectorIterator\n{\n typedef typename std::remove_cv<_V>::type V;\n\n template using enable_if_mutable =\n typename std::enable_if::value && !std::is_const<_V>::value, R>::type;\n\n using iterator_traits = std::iterator_traits *>;\n\n MemoryVector<_V, Flags> *d;\npublic:\n typedef typename iterator_traits::difference_type difference_type;\n typedef typename iterator_traits::value_type value_type;\n typedef typename iterator_traits::pointer pointer;\n typedef typename iterator_traits::reference reference;\n typedef typename iterator_traits::iterator_category iterator_category;\n\n constexpr MemoryVectorIterator(MemoryVector<_V, Flags> *dd) : d(dd) {}\n constexpr MemoryVectorIterator(const MemoryVectorIterator &) = default;\n constexpr MemoryVectorIterator(MemoryVectorIterator &&) = default;\n Vc_ALWAYS_INLINE MemoryVectorIterator &operator=(const MemoryVectorIterator &) = default;\n\n Vc_ALWAYS_INLINE void *orderBy() const { return d; }\n\n Vc_ALWAYS_INLINE difference_type operator-(const MemoryVectorIterator &rhs) const { return d - rhs.d; }\n Vc_ALWAYS_INLINE reference operator[](size_t i) const { return d[i]; }\n Vc_ALWAYS_INLINE reference operator*() const { return *d; }\n Vc_ALWAYS_INLINE pointer operator->() const { return d; }\n Vc_ALWAYS_INLINE MemoryVectorIterator &operator++() { ++d; return *this; }\n Vc_ALWAYS_INLINE MemoryVectorIterator operator++(int) { MemoryVectorIterator r(*this); ++d; return r; }\n Vc_ALWAYS_INLINE MemoryVectorIterator &operator--() { --d; return *this; }\n Vc_ALWAYS_INLINE MemoryVectorIterator operator--(int) { MemoryVectorIterator r(*this); --d; return r; }\n Vc_ALWAYS_INLINE MemoryVectorIterator &operator+=(size_t n) { d += n; return *this; }\n Vc_ALWAYS_INLINE MemoryVectorIterator &operator-=(size_t n) { d -= n; return *this; }\n Vc_ALWAYS_INLINE MemoryVectorIterator operator+(size_t n) const { return MemoryVectorIterator(d + n); }\n Vc_ALWAYS_INLINE MemoryVectorIterator operator-(size_t n) const { return MemoryVectorIterator(d - n); }\n};\n\ntemplate\nVc_ALWAYS_INLINE bool operator==(const MemoryVectorIterator &l, const MemoryVectorIterator &r)\n{\n return l.orderBy() == r.orderBy();\n}\ntemplate\nVc_ALWAYS_INLINE bool operator!=(const MemoryVectorIterator &l, const MemoryVectorIterator &r)\n{\n return l.orderBy() != r.orderBy();\n}\ntemplate\nVc_ALWAYS_INLINE bool operator>=(const MemoryVectorIterator &l, const MemoryVectorIterator &r)\n{\n return l.orderBy() >= r.orderBy();\n}\ntemplate\nVc_ALWAYS_INLINE bool operator<=(const MemoryVectorIterator &l, const MemoryVectorIterator &r)\n{\n return l.orderBy() <= r.orderBy();\n}\ntemplate\nVc_ALWAYS_INLINE bool operator> (const MemoryVectorIterator &l, const MemoryVectorIterator &r)\n{\n return l.orderBy() > r.orderBy();\n}\ntemplate\nVc_ALWAYS_INLINE bool operator< (const MemoryVectorIterator &l, const MemoryVectorIterator &r)\n{\n return l.orderBy() < r.orderBy();\n}\n/*}}}*/\n#undef Vc_MEM_OPERATOR_EQ\n\n#define Vc_VPH_OPERATOR(op) \\\n template \\\n decltype(std::declval() op std::declval()) operator op( \\\n const MemoryVector &x, const MemoryVector &y) \\\n { \\\n return x.value() op y.value(); \\\n }\nVc_ALL_ARITHMETICS(Vc_VPH_OPERATOR);\nVc_ALL_BINARY (Vc_VPH_OPERATOR);\nVc_ALL_COMPARES (Vc_VPH_OPERATOR);\n#undef Vc_VPH_OPERATOR\n\ntemplate> class MemoryRange/*{{{*/\n{\n Parent *m_parent;\n size_t m_first;\n size_t m_last;\n\npublic:\n MemoryRange(Parent *p, size_t firstIndex, size_t lastIndex)\n : m_parent(p), m_first(firstIndex), m_last(lastIndex)\n {}\n\n MemoryVectorIterator begin() const { return &m_parent->vector(m_first , Flags()); }\n MemoryVectorIterator end() const { return &m_parent->vector(m_last + 1, Flags()); }\n};/*}}}*/\ntemplate class MemoryDimensionBase;\ntemplate class MemoryDimensionBase // {{{1\n{\n private:\n Parent *p() { return static_cast(this); }\n const Parent *p() const { return static_cast(this); }\n public:\n /**\n * The type of the scalar entries in the array.\n */\n typedef typename V::EntryType EntryType;\n\n /**\n * Returns a pointer to the start of the allocated memory.\n */\n Vc_ALWAYS_INLINE Vc_PURE EntryType *entries() { return &p()->m_mem[0]; }\n /// Const overload of the above function.\n Vc_ALWAYS_INLINE Vc_PURE const EntryType *entries() const { return &p()->m_mem[0]; }\n\n /**\n * Returns the \\p i-th scalar value in the memory.\n */\n Vc_ALWAYS_INLINE Vc_PURE EntryType &scalar(size_t i) { return entries()[i]; }\n /// Const overload of the above function.\n Vc_ALWAYS_INLINE Vc_PURE const EntryType scalar(size_t i) const { return entries()[i]; }\n\n#ifdef DOXYGEN\n /**\n * Cast operator to the scalar type. This allows to use the object very much like a standard\n * C array.\n */\n Vc_ALWAYS_INLINE Vc_PURE operator EntryType*() { return entries(); }\n /// Const overload of the above function.\n Vc_ALWAYS_INLINE Vc_PURE operator const EntryType*() const { return entries(); }\n#else\n // The above conversion operator allows implicit conversion to bool. To prohibit this\n // conversion we use SFINAE to allow only conversion to EntryType* and void*.\n template ::type, EntryType *>::value ||\n std::is_same::type, void *>::value,\n int>::type = 0>\n Vc_ALWAYS_INLINE Vc_PURE operator T()\n {\n return entries();\n }\n template ::value ||\n std::is_same::value,\n int>::type = 0>\n Vc_ALWAYS_INLINE Vc_PURE operator T() const\n {\n return entries();\n }\n#endif\n\n /**\n *\n */\n template\n Vc_ALWAYS_INLINE MemoryRange range(size_t firstIndex, size_t lastIndex, Flags) {\n return MemoryRange(p(), firstIndex, lastIndex);\n }\n Vc_ALWAYS_INLINE MemoryRange range(size_t firstIndex, size_t lastIndex) {\n return MemoryRange(p(), firstIndex, lastIndex);\n }\n template\n Vc_ALWAYS_INLINE MemoryRange range(size_t firstIndex, size_t lastIndex, Flags) const {\n return MemoryRange(p(), firstIndex, lastIndex);\n }\n Vc_ALWAYS_INLINE MemoryRange range(size_t firstIndex, size_t lastIndex) const {\n return MemoryRange(p(), firstIndex, lastIndex);\n }\n\n /**\n * Returns the \\p i-th scalar value in the memory.\n */\n Vc_ALWAYS_INLINE EntryType &operator[](size_t i) { return entries()[i]; }\n /// Const overload of the above function.\n Vc_ALWAYS_INLINE const EntryType &operator[](size_t i) const { return entries()[i]; }\n\n /**\n * Uses a vector gather to combine the entries at the indexes in \\p i into the returned\n * vector object.\n *\n * \\param i An integer vector. It determines the entries to be gathered.\n * \\returns A vector object. Modification of this object will not modify the values in\n * memory.\n *\n * \\warning The API of this function might change in future versions of Vc to additionally\n * support scatters.\n */\n template Vc_ALWAYS_INLINE Vc_PURE V operator[](Vector i) const\n {\n return V(entries(), i);\n }\n};\ntemplate class MemoryDimensionBase // {{{1\n{\n private:\n Parent *p() { return static_cast(this); }\n const Parent *p() const { return static_cast(this); }\n public:\n /**\n * The type of the scalar entries in the array.\n */\n typedef typename V::EntryType EntryType;\n\n static constexpr size_t rowCount() { return Parent::RowCount; }\n\n /**\n * Returns a pointer to the start of the allocated memory.\n */\n Vc_ALWAYS_INLINE Vc_PURE EntryType *entries(size_t x = 0) { return &p()->m_mem[x][0]; }\n /// Const overload of the above function.\n Vc_ALWAYS_INLINE Vc_PURE const EntryType *entries(size_t x = 0) const { return &p()->m_mem[x][0]; }\n\n /**\n * Returns the \\p i,j-th scalar value in the memory.\n */\n Vc_ALWAYS_INLINE Vc_PURE EntryType &scalar(size_t i, size_t j) { return entries(i)[j]; }\n /// Const overload of the above function.\n Vc_ALWAYS_INLINE Vc_PURE const EntryType scalar(size_t i, size_t j) const { return entries(i)[j]; }\n\n /**\n * Returns the \\p i-th row in the memory.\n */\n Vc_ALWAYS_INLINE Vc_PURE RowMemory &operator[](size_t i) {\n return p()->m_mem[i];\n }\n /// Const overload of the above function.\n Vc_ALWAYS_INLINE Vc_PURE const RowMemory &operator[](size_t i) const {\n return p()->m_mem[i];\n }\n\n /**\n * \\return the number of rows in the array.\n *\n * \\note This function can be eliminated by an optimizing compiler.\n */\n Vc_ALWAYS_INLINE Vc_PURE size_t rowsCount() const { return p()->rowsCount(); }\n};\n\n//dox{{{1\n/**\n * \\headerfile memorybase.h \n *\n * Common interface to all Memory classes, independent of allocation on the stack or heap.\n *\n * \\param V The vector type you want to operate on. (e.g. float_v or uint_v)\n * \\param Parent This type is the complete type of the class that derives from MemoryBase.\n * \\param Dimension The number of dimensions the implementation provides.\n * \\param RowMemory Class to be used to work on a single row.\n */\ntemplate class MemoryBase : public MemoryDimensionBase //{{{1\n{\n static_assert((V::size() * sizeof(typename V::EntryType)) % V::MemoryAlignment == 0,\n \"Vc::Memory can only be used for data-parallel types storing a number \"\n \"of values that's a multiple of the memory alignment.\");\n\n private:\n Parent *p() { return static_cast(this); }\n const Parent *p() const { return static_cast(this); }\n\n template \n using vector_reference = MayAlias> &;\n template \n using const_vector_reference = const MayAlias> &;\n\n public:\n /**\n * The type of the scalar entries in the array.\n */\n typedef typename V::EntryType EntryType;\n\n /**\n * \\return the number of scalar entries in the array. This function is optimized away\n * if a constant size array is used.\n */\n Vc_ALWAYS_INLINE Vc_PURE size_t entriesCount() const { return p()->entriesCount(); }\n /**\n * \\return the number of vector entries that span the array. This function is optimized away\n * if a constant size array is used.\n */\n Vc_ALWAYS_INLINE Vc_PURE size_t vectorsCount() const { return p()->vectorsCount(); }\n\n using MemoryDimensionBase::entries;\n using MemoryDimensionBase::scalar;\n\n /**\n * Return a (vectorized) iterator to the start of this memory object.\n */\n template\n Vc_ALWAYS_INLINE MemoryVectorIterator< V, Flags> begin(Flags flags = Flags()) { return &firstVector(flags); }\n //! const overload of the above\n template\n Vc_ALWAYS_INLINE MemoryVectorIterator begin(Flags flags = Flags()) const { return &firstVector(flags); }\n\n /**\n * Return a (vectorized) iterator to the end of this memory object.\n */\n template\n Vc_ALWAYS_INLINE MemoryVectorIterator< V, Flags> end(Flags flags = Flags()) { return &lastVector(flags) + 1; }\n //! const overload of the above\n template\n Vc_ALWAYS_INLINE MemoryVectorIterator end(Flags flags = Flags()) const { return &lastVector(flags) + 1; }\n\n /**\n * \\param i Selects the offset, where the vector should be read.\n *\n * \\return a smart object to wrap the \\p i-th vector in the memory.\n *\n * The return value can be used as any other vector object. I.e. you can substitute\n * something like\n * \\code\n * float_v a = ..., b = ...;\n * a += b;\n * \\endcode\n * with\n * \\code\n * mem.vector(i) += b;\n * \\endcode\n *\n * This function ensures that only \\em aligned loads and stores are used. Thus it only allows to\n * access memory at fixed strides. If access to known offsets from the aligned vectors is\n * needed the vector(size_t, int) function can be used.\n */\n template \n Vc_ALWAYS_INLINE Vc_PURE\n typename std::enable_if::value,\n vector_reference>::type\n vector(size_t i, Flags = Flags())\n {\n return *aliasing_cast>(&entries()[i * V::Size]);\n }\n /** \\brief Const overload of the above function\n *\n * \\param i Selects the offset, where the vector should be read.\n *\n * \\return a smart object to wrap the \\p i-th vector in the memory.\n */\n template \n Vc_ALWAYS_INLINE Vc_PURE\n typename std::enable_if::value,\n const_vector_reference>::type\n vector(size_t i, Flags = Flags()) const\n {\n return *aliasing_cast>(&entries()[i * V::Size]);\n }\n\n /**\n * \\return a smart object to wrap the vector starting from the \\p i-th scalar entry in the memory.\n *\n * Example:\n * \\code\n * Memory mem;\n * mem.setZero();\n * for (int i = 0; i < mem.entriesCount(); i += float_v::Size) {\n * mem.vectorAt(i) += b;\n * }\n * \\endcode\n *\n * \\param i Specifies the scalar entry from where the vector will be loaded/stored. I.e. the\n * values scalar(i), scalar(i + 1), ..., scalar(i + V::Size - 1) will be read/overwritten.\n *\n * \\param flags You must take care to determine whether an unaligned load/store is\n * required. Per default an unaligned load/store is used. If \\p i is a multiple of \\c V::Size\n * you may want to pass Vc::Aligned here.\n */\n template \n Vc_ALWAYS_INLINE Vc_PURE vector_reference vectorAt(size_t i,\n Flags flags = Flags())\n {\n return *aliasing_cast>(&entries()[i]);\n }\n /** \\brief Const overload of the above function\n *\n * \\return a smart object to wrap the vector starting from the \\p i-th scalar entry in the memory.\n *\n * \\param i Specifies the scalar entry from where the vector will be loaded/stored. I.e. the\n * values scalar(i), scalar(i + 1), ..., scalar(i + V::Size - 1) will be read/overwritten.\n *\n * \\param flags You must take care to determine whether an unaligned load/store is\n * required. Per default an unaligned load/store is used. If \\p i is a multiple of \\c V::Size\n * you may want to pass Vc::Aligned here.\n */\n template \n Vc_ALWAYS_INLINE Vc_PURE const_vector_reference vectorAt(\n size_t i, Flags flags = Flags()) const\n {\n return *aliasing_cast>(&entries()[i]);\n }\n\n /**\n * \\return a smart object to wrap the \\p i-th vector + \\p shift in the memory.\n *\n * This function ensures that only \\em unaligned loads and stores are used.\n * It allows to access memory at any location aligned to the entry type.\n *\n * \\param i Selects the memory location of the i-th vector. Thus if \\p V::Size == 4 and\n * \\p i is set to 3 the base address for the load/store will be the 12th entry\n * (same as \\p &mem[12]).\n * \\param shift Shifts the base address determined by parameter \\p i by \\p shift many\n * entries. Thus \\p vector(3, 1) for \\p V::Size == 4 will load/store the\n * 13th - 16th entries (same as \\p &mem[13]).\n *\n * \\note Any shift value is allowed as long as you make sure it stays within bounds of the\n * allocated memory. Shift values that are a multiple of \\p V::Size will \\em not result in\n * aligned loads. You have to use the above vector(size_t) function for aligned loads\n * instead.\n *\n * \\note Thus a simple way to access vectors randomly is to set \\p i to 0 and use \\p shift as the\n * parameter to select the memory address:\n * \\code\n * // don't use:\n * mem.vector(i / V::Size, i % V::Size) += 1;\n * // instead use:\n * mem.vector(0, i) += 1;\n * \\endcode\n */\n template \n Vc_ALWAYS_INLINE Vc_PURE typename std::enable_if<\n std::is_convertible::value,\n vector_reference() | Unaligned)>>::type\n vector(size_t i, ShiftT shift, Flags = Flags())\n {\n return *aliasing_cast<\n MemoryVector() | Unaligned)>>(\n &entries()[i * V::Size + shift]);\n }\n /// Const overload of the above function.\n template \n Vc_ALWAYS_INLINE Vc_PURE typename std::enable_if<\n std::is_convertible::value,\n const_vector_reference() | Unaligned)>>::type\n vector(size_t i, ShiftT shift, Flags = Flags()) const\n {\n return *aliasing_cast<\n MemoryVector() | Unaligned)>>(\n &entries()[i * V::Size + shift]);\n }\n\n /**\n * \\return the first vector in the allocated memory.\n *\n * This function is simply a shorthand for vector(0).\n */\n template \n Vc_ALWAYS_INLINE Vc_PURE vector_reference firstVector(Flags f = Flags())\n {\n return vector(0, f);\n }\n /// Const overload of the above function.\n template \n Vc_ALWAYS_INLINE Vc_PURE const_vector_reference firstVector(\n Flags f = Flags()) const\n {\n return vector(0, f);\n }\n\n /**\n * \\return the last vector in the allocated memory.\n *\n * This function is simply a shorthand for vector(vectorsCount() - 1).\n */\n template \n Vc_ALWAYS_INLINE Vc_PURE vector_reference lastVector(Flags f = Flags())\n {\n return vector(vectorsCount() - 1, f);\n }\n /// Const overload of the above function.\n template \n Vc_ALWAYS_INLINE Vc_PURE const_vector_reference lastVector(\n Flags f = Flags()) const\n {\n return vector(vectorsCount() - 1, f);\n }\n\n Vc_ALWAYS_INLINE Vc_PURE V gather(const unsigned char *indexes) const { return V(entries(), typename V::IndexType(indexes, Vc::Unaligned)); }\n Vc_ALWAYS_INLINE Vc_PURE V gather(const unsigned short *indexes) const { return V(entries(), typename V::IndexType(indexes, Vc::Unaligned)); }\n Vc_ALWAYS_INLINE Vc_PURE V gather(const unsigned int *indexes) const { return V(entries(), typename V::IndexType(indexes, Vc::Unaligned)); }\n Vc_ALWAYS_INLINE Vc_PURE V gather(const unsigned long *indexes) const { return V(entries(), typename V::IndexType(indexes, Vc::Unaligned)); }\n\n /**\n * Zero the whole memory area.\n */\n Vc_ALWAYS_INLINE void setZero() {\n V zero(Vc::Zero);\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) = zero;\n }\n }\n\n /**\n * Assign a value to all vectors in the array.\n */\n template\n Vc_ALWAYS_INLINE Parent &operator=(U &&x) {\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) = std::forward(x);\n }\n }\n\n /**\n * (Inefficient) shorthand to add up two arrays.\n */\n template\n inline Parent &operator+=(const MemoryBase &rhs) {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) += rhs.vector(i);\n }\n return static_cast(*this);\n }\n\n /**\n * (Inefficient) shorthand to subtract two arrays.\n */\n template\n inline Parent &operator-=(const MemoryBase &rhs) {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) -= rhs.vector(i);\n }\n return static_cast(*this);\n }\n\n /**\n * (Inefficient) shorthand to multiply two arrays.\n */\n template\n inline Parent &operator*=(const MemoryBase &rhs) {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) *= rhs.vector(i);\n }\n return static_cast(*this);\n }\n\n /**\n * (Inefficient) shorthand to divide two arrays.\n */\n template\n inline Parent &operator/=(const MemoryBase &rhs) {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) /= rhs.vector(i);\n }\n return static_cast(*this);\n }\n\n /**\n * (Inefficient) shorthand to add a value to an array.\n */\n inline Parent &operator+=(EntryType rhs) {\n V v(rhs);\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) += v;\n }\n return static_cast(*this);\n }\n\n /**\n * (Inefficient) shorthand to subtract a value from an array.\n */\n inline Parent &operator-=(EntryType rhs) {\n V v(rhs);\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) -= v;\n }\n return static_cast(*this);\n }\n\n /**\n * (Inefficient) shorthand to multiply a value to an array.\n */\n inline Parent &operator*=(EntryType rhs) {\n V v(rhs);\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) *= v;\n }\n return static_cast(*this);\n }\n\n /**\n * (Inefficient) shorthand to divide an array with a value.\n */\n inline Parent &operator/=(EntryType rhs) {\n V v(rhs);\n for (size_t i = 0; i < vectorsCount(); ++i) {\n vector(i) /= v;\n }\n return static_cast(*this);\n }\n\n /**\n * (Inefficient) shorthand compare equality of two arrays.\n */\n template\n inline bool operator==(const MemoryBase &rhs) const {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n if (!(V(vector(i)) == V(rhs.vector(i))).isFull()) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * (Inefficient) shorthand compare two arrays.\n */\n template\n inline bool operator!=(const MemoryBase &rhs) const {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n if (!(V(vector(i)) == V(rhs.vector(i))).isEmpty()) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * (Inefficient) shorthand compare two arrays.\n */\n template\n inline bool operator<(const MemoryBase &rhs) const {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n if (!(V(vector(i)) < V(rhs.vector(i))).isFull()) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * (Inefficient) shorthand compare two arrays.\n */\n template\n inline bool operator<=(const MemoryBase &rhs) const {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n if (!(V(vector(i)) <= V(rhs.vector(i))).isFull()) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * (Inefficient) shorthand compare two arrays.\n */\n template\n inline bool operator>(const MemoryBase &rhs) const {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n if (!(V(vector(i)) > V(rhs.vector(i))).isFull()) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * (Inefficient) shorthand compare two arrays.\n */\n template\n inline bool operator>=(const MemoryBase &rhs) const {\n assert(vectorsCount() == rhs.vectorsCount());\n for (size_t i = 0; i < vectorsCount(); ++i) {\n if (!(V(vector(i)) >= V(rhs.vector(i))).isFull()) {\n return false;\n }\n }\n return true;\n }\n};\n\nnamespace Detail\n{\ntemplate \ninline void copyVectors(MemoryBase &dst,\n const MemoryBase &src)\n{\n const size_t vectorsCount = dst.vectorsCount();\n size_t i = 3;\n for (; i < vectorsCount; i += 4) {\n const V tmp3 = src.vector(i - 3);\n const V tmp2 = src.vector(i - 2);\n const V tmp1 = src.vector(i - 1);\n const V tmp0 = src.vector(i - 0);\n dst.vector(i - 3) = tmp3;\n dst.vector(i - 2) = tmp2;\n dst.vector(i - 1) = tmp1;\n dst.vector(i - 0) = tmp0;\n }\n for (i -= 3; i < vectorsCount; ++i) {\n dst.vector(i) = src.vector(i);\n }\n}\n} // namespace Detail\n\n} // namespace Common\n} // namespace Vc\n\n#endif // VC_COMMON_MEMORYBASE_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/memoryfwd.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2011-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_MEMORYFWD_H_\n#define VC_COMMON_MEMORYFWD_H_\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\ntemplate \nclass Memory;\n\ntemplate \nclass MemoryBase;\n} // namespace Common\n\nusing Common::Memory;\n} // namespace Vc\n\n#endif // VC_COMMON_MEMORYFWD_H_\n" }, { "path": "3rdparty/Vc/Vc/common/operators.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2012-2016 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef COMMON_OPERATORS_H_\n#define COMMON_OPERATORS_H_\n#include \"simdarray.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Detail\n{\ntemplate \nenable_if::value, U> is_convertible_to_any_vector(Vector);\ntemplate T is_convertible_to_any_vector(Vector);\n\ntemplate ::value,\n bool = std::is_integral::value>\nstruct FundamentalReturnType;\ntemplate \nusing fundamental_return_t = typename FundamentalReturnType::type;\n\ntemplate struct FundamentalReturnType {\n using type = typename std::conditional<\n std::is_arithmetic::value,\n typename std::conditional<(sizeof(T) < sizeof(U)), U, T>::type,\n // U is not arithmetic, e.g. an enum or a type with e.g. operator int()\n T>::type;\n};\ntemplate struct FundamentalReturnType {\n using type = typename std::conditional<\n std::is_arithmetic::value, U,\n // U is not arithmetic, e.g. an enum or a type with e.g. operator int()\n T>::type;\n};\ntemplate struct FundamentalReturnType {\n using type = T;\n};\n\ntemplate struct my_make_signed : public std::make_signed {\n};\ntemplate <> struct my_make_signed {\n using type = bool;\n};\n\ntemplate \nstruct higher_conversion_rank {\n template \n using fix_sign =\n typename std::conditional<(std::is_unsigned::value ||\n std::is_unsigned::value),\n typename std::make_unsigned::type, A>::type;\n using T = typename my_make_signed::type;\n using U = typename my_make_signed::type;\n template \n using c = typename std::conditional::value ||\n std::is_same::value,\n Test, Otherwise>::type;\n\n using type = fix_sign>>>>>;\n};\n\ntemplate struct FundamentalReturnType {\n template \n using c = typename std::conditional::type;\n using type =\n c<(sizeof(T) > sizeof(U)), T,\n c<(sizeof(T) < sizeof(U)), U, typename higher_conversion_rank::type>>;\n};\n\ntemplate struct ReturnTypeImpl {\n // no type => SFINAE\n};\n// 1. Vector × Vector\ntemplate \nstruct ReturnTypeImpl, Vector, Uq, void> {\n using type = Vc::Vector, Abi>;\n};\n// 2. Vector × int\ntemplate \nstruct ReturnTypeImpl, int, Uq, void> {\n // conversion from int is always allowed (because its the default when you hardcode a\n // number)\n using type = Vc::Vector;\n};\n// 3. Vector × unsigned\ntemplate \nstruct ReturnTypeImpl, uint, Uq, void> {\n // conversion from unsigned int is allowed for all integral Vector, but ensures\n // unsigned result\n using type = Vc::Vector<\n typename std::conditional::value, std::make_unsigned,\n std::enable_if>::type::type,\n Abi>;\n};\n// 4. Vector × {enum, arithmetic}\ntemplate \nstruct ReturnTypeImpl<\n Vector, U, Uq,\n enable_if::value && !std::is_same::value &&\n !std::is_same::value &&\n Traits::is_valid_vector_argument>::value,\n void>> {\n using type = Vc::Vector, Abi>;\n};\n// 5. Vector × UDT\ntemplate \nstruct ReturnTypeImpl<\n Vector, U, Uq,\n enable_if::value && !Traits::is_simd_vector::value &&\n Traits::is_valid_vector_argument(std::declval()))>::value,\n void>> {\n using type =\n Vc::Vector(\n std::declval()))>,\n Abi>;\n};\ntemplate >\nusing ReturnType = typename ReturnTypeImpl::type;\n\ntemplate struct is_a_type : public std::true_type {\n};\n\n#ifdef Vc_ENABLE_FLOAT_BIT_OPERATORS\n#define Vc_TEST_FOR_BUILTIN_OPERATOR(op_) true\n#else\n#define Vc_TEST_FOR_BUILTIN_OPERATOR(op_) \\\n Detail::is_a_type() \\\n op_ std::declval())>::value\n#endif\n} // namespace Detail\n\n#define Vc_GENERIC_OPERATOR(op_) \\\n template , U>> \\\n Vc_ALWAYS_INLINE enable_if, R>::value && \\\n std::is_convertible::value, \\\n R> \\\n operator op_(Vector x, U &&y) \\\n { \\\n return Detail::operator op_(R(x), R(std::forward(y))); \\\n } \\\n template , U>> \\\n Vc_ALWAYS_INLINE enable_if::value && \\\n std::is_convertible, R>::value && \\\n std::is_convertible::value, \\\n R> \\\n operator op_(U &&x, Vector y) \\\n { \\\n return Detail::operator op_(R(std::forward(x)), R(y)); \\\n } \\\n template , U>> \\\n Vc_ALWAYS_INLINE enable_if, R>::value && \\\n std::is_convertible::value, \\\n Vector &> \\\n operator op_##=(Vector &x, U &&y) \\\n { \\\n x = Detail::operator op_(R(x), R(std::forward(y))); \\\n return x; \\\n }\n\n#define Vc_LOGICAL_OPERATOR(op_) \\\n template \\\n Vc_ALWAYS_INLINE typename Vector::Mask operator op_(Vector x, \\\n Vector y) \\\n { \\\n return !!x op_ !!y; \\\n } \\\n template \\\n Vc_ALWAYS_INLINE \\\n enable_if, Vector>::value && \\\n std::is_convertible, Vector>::value, \\\n typename Detail::ReturnType, Vector>::Mask> \\\n operator op_(Vector x, Vector y) \\\n { \\\n return !!x op_ !!y; \\\n } \\\n template \\\n Vc_ALWAYS_INLINE enable_if())>::value, \\\n typename Vector::Mask> \\\n operator op_(Vector x, U &&y) \\\n { \\\n using M = typename Vector::Mask; \\\n return !!x op_ M(!!std::forward(y)); \\\n } \\\n template \\\n Vc_ALWAYS_INLINE enable_if())>::value, \\\n typename Vector::Mask> \\\n operator op_(U &&x, Vector y) \\\n { \\\n using M = typename Vector::Mask; \\\n return M(!!std::forward(x)) op_ !!y; \\\n }\n\n#define Vc_COMPARE_OPERATOR(op_) \\\n template , U>> \\\n Vc_ALWAYS_INLINE enable_if, R>::value && \\\n std::is_convertible::value, \\\n typename R::Mask> \\\n operator op_(Vector x, U &&y) \\\n { \\\n return Detail::operator op_(R(x), R(std::forward(y))); \\\n } \\\n template , U>> \\\n Vc_ALWAYS_INLINE \\\n enable_if>::value && \\\n std::is_convertible, R>::value && \\\n std::is_convertible::value, \\\n typename R::Mask> \\\n operator op_(U &&x, Vector y) \\\n { \\\n return Detail::operator op_(R(std::forward(x)), R(y)); \\\n }\n\nVc_ALL_LOGICAL (Vc_LOGICAL_OPERATOR);\nVc_ALL_BINARY (Vc_GENERIC_OPERATOR);\nVc_ALL_ARITHMETICS(Vc_GENERIC_OPERATOR);\nVc_ALL_COMPARES (Vc_COMPARE_OPERATOR);\n\n#undef Vc_LOGICAL_OPERATOR\n#undef Vc_GENERIC_OPERATOR\n#undef Vc_COMPARE_OPERATOR\n#undef Vc_INVALID_OPERATOR\n\n} // namespace Vc\n#endif // COMMON_OPERATORS_H_\n" }, { "path": "3rdparty/Vc/Vc/common/permutation.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_PERMUTATION_H_\n#define VC_COMMON_PERMUTATION_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Permutation\n{\nstruct ReversedTag {};\nconstexpr ReversedTag Reversed{};\n} // namespace Permutation\n}\n\n#endif // VC_COMMON_PERMUTATION_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/scatterimplementation.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_SCATTERIMPLEMENTATION_H_\n#define VC_COMMON_SCATTERIMPLEMENTATION_H_\n\n#include \"gatherimplementation.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace Common\n{\n\ntemplate \nVc_ALWAYS_INLINE void executeScatter(SetIndexZeroT,\n V &v,\n MT *mem,\n IT indexes,\n typename V::MaskArgument mask)\n{\n indexes.setZeroInverted(static_cast(mask));\n // Huh?\n const V tmp(mem, indexes);\n where(mask) | v = tmp;\n}\n\ntemplate \nVc_ALWAYS_INLINE void executeScatter(SimpleLoopT,\n V &v,\n MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask)\n{\n if (Vc_IS_UNLIKELY(mask.isEmpty())) {\n return;\n }\n Common::unrolled_loop([&](std::size_t i) {\n if (mask[i])\n mem[indexes[i]] = v[i];\n });\n}\n\ntemplate \nVc_ALWAYS_INLINE void executeScatter(BitScanLoopT,\n V &v,\n MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask)\n{\n size_t bits = mask.toInt();\n while (Vc_IS_LIKELY(bits > 0)) {\n size_t i, j;\n asm(\"bsf %[bits],%[i]\\n\\t\"\n \"bsr %[bits],%[j]\\n\\t\"\n \"btr %[i],%[bits]\\n\\t\"\n \"btr %[j],%[bits]\\n\\t\"\n : [i] \"=r\"(i), [j] \"=r\"(j), [bits] \"+r\"(bits));\n mem[indexes[i]] = v[i];\n mem[indexes[j]] = v[j];\n }\n\n /* Alternative from Vc::SSE (0.7)\n int bits = mask.toInt();\n while (bits) {\n const int i = _bit_scan_forward(bits);\n bits ^= (1 << i); // btr?\n mem[indexes[i]] = v[i];\n }\n */\n}\n\ntemplate \nVc_ALWAYS_INLINE void executeScatter(PopcntSwitchT,\n V &v,\n MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask,\n enable_if = nullarg)\n{\n unsigned int bits = mask.toInt();\n unsigned int low, high = 0;\n switch (Vc::Detail::popcnt16(bits)) {\n case 16:\n v.scatter(mem, indexes);\n break;\n case 15:\n low = _bit_scan_forward(bits);\n bits ^= 1 << low;\n mem[indexes[low]] = v[low];\n case 14:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n high = (1 << high);\n case 13:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n mem[indexes[low]] = v[low];\n case 12:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n high = (1 << high);\n case 11:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n mem[indexes[low]] = v[low];\n case 10:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n high = (1 << high);\n case 9:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n mem[indexes[low]] = v[low];\n case 8:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n high = (1 << high);\n case 7:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n mem[indexes[low]] = v[low];\n case 6:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n high = (1 << high);\n case 5:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n mem[indexes[low]] = v[low];\n case 4:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n high = (1 << high);\n case 3:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n mem[indexes[low]] = v[low];\n case 2:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n case 1:\n low = _bit_scan_forward(bits);\n mem[indexes[low]] = v[low];\n case 0:\n break;\n }\n}\ntemplate \nVc_ALWAYS_INLINE void executeScatter(PopcntSwitchT,\n V &v,\n MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask,\n enable_if = nullarg)\n{\n unsigned int bits = mask.toInt();\n unsigned int low, high = 0;\n switch (Vc::Detail::popcnt8(bits)) {\n case 8:\n v.scatter(mem, indexes);\n break;\n case 7:\n low = _bit_scan_forward(bits);\n bits ^= 1 << low;\n mem[indexes[low]] = v[low];\n case 6:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n high = (1 << high);\n case 5:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n mem[indexes[low]] = v[low];\n case 4:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n high = (1 << high);\n case 3:\n low = _bit_scan_forward(bits);\n bits ^= high | (1 << low);\n mem[indexes[low]] = v[low];\n case 2:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n case 1:\n low = _bit_scan_forward(bits);\n mem[indexes[low]] = v[low];\n case 0:\n break;\n }\n}\ntemplate \nVc_ALWAYS_INLINE void executeScatter(PopcntSwitchT,\n V &v,\n MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask,\n enable_if = nullarg)\n{\n unsigned int bits = mask.toInt();\n unsigned int low, high = 0;\n switch (Vc::Detail::popcnt4(bits)) {\n case 4:\n v.scatter(mem, indexes);\n break;\n case 3:\n low = _bit_scan_forward(bits);\n bits ^= 1 << low;\n mem[indexes[low]] = v[low];\n case 2:\n high = _bit_scan_reverse(bits);\n mem[indexes[high]] = v[high];\n case 1:\n low = _bit_scan_forward(bits);\n mem[indexes[low]] = v[low];\n case 0:\n break;\n }\n}\ntemplate \nVc_ALWAYS_INLINE void executeScatter(PopcntSwitchT,\n V &v,\n MT *mem,\n const IT &indexes,\n typename V::MaskArgument mask,\n enable_if = nullarg)\n{\n unsigned int bits = mask.toInt();\n unsigned int low;\n switch (Vc::Detail::popcnt4(bits)) {\n case 2:\n v.scatter(mem, indexes);\n break;\n case 1:\n low = _bit_scan_forward(bits);\n mem[indexes[low]] = v[low];\n case 0:\n break;\n }\n}\n\n} // namespace Common\n} // namespace Vc\n\n#endif // VC_COMMON_SCATTERIMPLEMENTATION_H_\n" }, { "path": "3rdparty/Vc/Vc/common/scatterinterface.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n///////////////////////////////////////////////////////////////////////////////////////////\n// scatters\n// A scatter takes the following arguments:\n// 1. A pointer to memory of any type that EntryType can convert to.\n// 2. An indexes “vector”. The requirement is that the type implements the subscript operator,\n// stores «Size» valid index values, and each offset to the pointer above yields a valid\n// memory location for reading.\n// 3. Optionally the third argument may be a mask. The mask disables several memory stores and\n// thus removes the requirements in (2.) for the disabled entries.\n\nprivate:\n /**\\internal\n * This function implements a scatter given a pointer to memory \\p mem and some\n * container object storing the scatter \\p indexes.\n *\n * \\param mem This pointer must be aligned correctly for the type \\p MT. This is the\n * natural behavior of C++, so this is typically the case.\n * \\param indexes This object contains at least \\VSize{T} indexes that denote the\n * offset in \\p mem where the components for the current vector should be copied to.\n * The offset is not in Bytes, but in multiples of `sizeof(MT)`.\n */\n // enable_if::value && has_subscript_operator::value>\n template \n inline void scatterImplementation(MT *mem, IT &&indexes) const;\n\n /**\\internal\n * This overload of the above function adds a \\p mask argument to disable memory\n * accesses at the \\p indexes offsets where \\p mask is \\c false.\n */\n template \n inline void scatterImplementation(MT *mem, IT &&indexes, MaskArgument mask) const;\n\npublic:\n#define Vc_ASSERT_SCATTER_PARAMETER_TYPES_ \\\n static_assert( \\\n std::is_convertible::value, \\\n \"The memory pointer needs to point to a type that the EntryType of this \" \\\n \"SIMD vector type can be converted to.\"); \\\n static_assert( \\\n Vc::Traits::has_subscript_operator::value, \\\n \"The indexes argument must be a type that implements the subscript operator.\"); \\\n static_assert( \\\n !Traits::is_simd_vector::value || \\\n Traits::simd_vector_size::value >= Size, \\\n \"If you use a SIMD vector for the indexes parameter, the index vector must \" \\\n \"have at least as many entries as this SIMD vector.\"); \\\n static_assert( \\\n !std::is_array::value || \\\n (std::rank::value == 1 && \\\n (std::extent::value == 0 || std::extent::value >= Size)), \\\n \"If you use a simple array for the indexes parameter, the array must have \" \\\n \"at least as many entries as this SIMD vector.\")\n\n /**\n * \\name Scatter functions\n *\n * Stores a vector to the objects at `mem[indexes[0]]`, `mem[indexes[1]]`,\n * `mem[indexes[2]]`, ...\n *\n * \\param mem A pointer to memory which contains objects of type \\p MT at the offsets\n * given by \\p indexes.\n * \\param indexes\n * \\param mask\n */\n ///@{\n\n /// Scatter function\n template ::value>>\n Vc_INTRINSIC void scatter(MT *mem, IT &&indexes) const\n {\n Vc_ASSERT_SCATTER_PARAMETER_TYPES_;\n scatterImplementation(mem, std::forward(indexes));\n }\n\n /// Masked scatter function\n template ::value>>\n Vc_INTRINSIC void scatter(MT *mem, IT &&indexes, MaskArgument mask) const\n {\n Vc_ASSERT_SCATTER_PARAMETER_TYPES_;\n scatterImplementation(mem, std::forward(indexes), mask);\n }\n ///@}\n\n#include \"scatterinterface_deprecated.h\"\n\n /**\\internal\n * \\name Scatter function to use from Vc::Common::subscript_operator\n *\n * \\param args\n * \\param mask\n */\n ///@{\n template \n Vc_INTRINSIC void scatter(const Common::ScatterArguments &args) const\n {\n scatter(args.address, args.indexes);\n }\n\n template \n Vc_INTRINSIC void scatter(const Common::ScatterArguments &args, MaskArgument mask) const\n {\n scatter(args.address, args.indexes, mask);\n }\n ///@}\n#undef Vc_ASSERT_SCATTER_PARAMETER_TYPES_\n" }, { "path": "3rdparty/Vc/Vc/common/scatterinterface_deprecated.h", "content": " /// \\name Deprecated Members\n ///@{\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void scatter(S1 *array, EntryType S1::*member1,\n IT indexes) const\n {\n scatter(Common::SubscriptOperation, true>(\n array, indexes)[member1]\n .scatterArguments());\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n * \\param mask If a mask is given only the active entries will be gathered/scattered.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void scatter(S1 *array, EntryType S1::*member1,\n IT indexes, MaskArgument mask) const\n {\n scatter(Common::SubscriptOperation, true>(\n array, indexes)[member1]\n .scatterArguments(),\n mask);\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param member2 If \\p member1 is a struct then \\p member2 selects the member to be read from that\n * struct (i.e. array[i].*member1.*member2 is read).\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void scatter(S1 *array, S2 S1::*member1,\n EntryType S2::*member2,\n IT indexes) const\n {\n scatter(Common::SubscriptOperation, true>(\n array, indexes)[member1][member2]\n .scatterArguments());\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param member1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param member2 If \\p member1 is a struct then \\p member2 selects the member to be read from that\n * struct (i.e. array[i].*member1.*member2 is read).\n * \\param indexes Determines the offsets into \\p array where the values are gathered from/scattered\n * to. The type of indexes can either be an integer vector or a type that supports\n * operator[] access.\n * \\param mask If a mask is given only the active entries will be gathered/scattered.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void scatter(S1 *array, S2 S1::*member1,\n EntryType S2::*member2, IT indexes,\n MaskArgument mask) const\n {\n scatter(Common::SubscriptOperation, true>(\n array, indexes)[member1][member2]\n .scatterArguments(),\n mask);\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param ptrMember1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param outerIndexes\n * \\param innerIndexes\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void scatter(S1 *array, EntryType *S1::*ptrMember1,\n IT1 outerIndexes,\n IT2 innerIndexes) const\n {\n scatter(Common::SubscriptOperation, true>(\n array, outerIndexes)[ptrMember1][innerIndexes]\n .scatterArguments());\n }\n\n /**\n * \\deprecated Use Vc::array or Vc::vector subscripting instead.\n *\n * \\param array A pointer into memory (without alignment restrictions).\n * \\param ptrMember1 If \\p array points to a struct, \\p member1 determines the member in the struct to\n * be read. Thus the offsets in \\p indexes are relative to the \\p array and not to\n * the size of the gathered type (i.e. array[i].*member1 is accessed instead of\n * (&(array->*member1))[i])\n * \\param outerIndexes\n * \\param innerIndexes\n * \\param mask If a mask is given only the active entries will be gathered/scattered.\n */\n template \n Vc_DEPRECATED(\"use the subscript operator to Vc::array or Vc::vector \"\n \"instead.\") inline void scatter(S1 *array, EntryType *S1::*ptrMember1,\n IT1 outerIndexes, IT2 innerIndexes,\n MaskArgument mask) const\n {\n scatter(Common::SubscriptOperation, true>(\n array, outerIndexes)[ptrMember1][innerIndexes]\n .scatterArguments(),\n mask);\n }\n ///@}\n" }, { "path": "3rdparty/Vc/Vc/common/set.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_SET_H_\n#define VC_COMMON_SET_H_\n\n#include \"macros.h\"\nnamespace Vc_VERSIONED_NAMESPACE\n{\nnamespace\n{\n static Vc_INTRINSIC Vc_CONST __m128i set(unsigned short x0, unsigned short x1, unsigned short x2, unsigned short x3,\n unsigned short x4, unsigned short x5, unsigned short x6, unsigned short x7)\n {\n#if defined(Vc_GNU_ASM)\n#if 0 // defined(__x86_64__)\n // it appears that the 32bit variant is always faster\n __m128i r;\n unsigned long long tmp0 = x3; tmp0 = (tmp0 << 16) | x2;\n unsigned long long tmp1 = x1; tmp1 = (tmp1 << 16) | x0;\n asm(\"vmovq %1,%0\" : \"=x\"(r) : \"r\"((tmp0 << 32) | tmp1));\n unsigned long long tmp2 = x7; tmp2 = (tmp2 << 16) | x6;\n unsigned long long tmp3 = x5; tmp3 = (tmp3 << 16) | x4;\n asm(\"vpinsrq $1,%1,%0,%0\" : \"+x\"(r) : \"r\"((tmp2 << 32) | tmp3));\n return r;\n#elif defined(Vc_USE_VEX_CODING)\n __m128i r0, r1;\n unsigned int tmp0 = x1; tmp0 = (tmp0 << 16) | x0;\n unsigned int tmp1 = x3; tmp1 = (tmp1 << 16) | x2;\n unsigned int tmp2 = x5; tmp2 = (tmp2 << 16) | x4;\n unsigned int tmp3 = x7; tmp3 = (tmp3 << 16) | x6;\n asm(\"vmovd %1,%0\" : \"=x\"(r0) : \"r\"(tmp0));\n asm(\"vpinsrd $1,%1,%0,%0\" : \"+x\"(r0) : \"r\"(tmp1));\n asm(\"vmovd %1,%0\" : \"=x\"(r1) : \"r\"(tmp2));\n asm(\"vpinsrd $1,%1,%0,%0\" : \"+x\"(r1) : \"r\"(tmp3));\n asm(\"vpunpcklqdq %1,%0,%0\" : \"+x\"(r0) : \"x\"(r1));\n return r0;\n#else\n __m128i r0, r1;\n unsigned int tmp0 = x1; tmp0 = (tmp0 << 16) | x0;\n unsigned int tmp1 = x3; tmp1 = (tmp1 << 16) | x2;\n unsigned int tmp2 = x5; tmp2 = (tmp2 << 16) | x4;\n unsigned int tmp3 = x7; tmp3 = (tmp3 << 16) | x6;\n asm(\"movd %1,%0\" : \"=x\"(r0) : \"r\"(tmp0));\n asm(\"pinsrd $1,%1,%0\" : \"+x\"(r0) : \"r\"(tmp1));\n asm(\"movd %1,%0\" : \"=x\"(r1) : \"r\"(tmp2));\n asm(\"pinsrd $1,%1,%0\" : \"+x\"(r1) : \"r\"(tmp3));\n asm(\"punpcklqdq %1,%0\" : \"+x\"(r0) : \"x\"(r1));\n return r0;\n#endif\n#else\n unsigned int tmp0 = x1; tmp0 = (tmp0 << 16) | x0;\n unsigned int tmp1 = x3; tmp1 = (tmp1 << 16) | x2;\n unsigned int tmp2 = x5; tmp2 = (tmp2 << 16) | x4;\n unsigned int tmp3 = x7; tmp3 = (tmp3 << 16) | x6;\n return _mm_setr_epi32(tmp0, tmp1, tmp2, tmp3);\n#endif\n }\n static Vc_INTRINSIC Vc_CONST __m128i set(short x0, short x1, short x2, short x3, short x4, short x5, short x6, short x7)\n {\n return set(static_cast(x0), static_cast(x1), static_cast(x2),\n static_cast(x3), static_cast(x4), static_cast(x5),\n static_cast(x6), static_cast(x7));\n }\n} // anonymous namespace\n} // namespace Vc\n\n#endif // VC_COMMON_SET_H_\n" }, { "path": "3rdparty/Vc/Vc/common/simd_cast.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_SIMD_CAST_H_\n#define VC_COMMON_SIMD_CAST_H_\n\n#include \n#include \"macros.h\"\n\n// declare a bogus simd_cast function template in the global namespace to enable ADL for\n// simd_cast\ntemplate void simd_cast();\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n/**\n * Casts the argument \\p x from type \\p From to type \\p To.\n *\n * This function implements the trivial case where \\p To and \\p From are the same type.\n *\n * \\param x The object of type \\p From to be converted to type \\p To.\n * \\returns An object of type \\p To with all vector components converted according to\n * standard conversion behavior as mandated by the C++ standard for the\n * underlying arithmetic types.\n */\ntemplate \nVc_INTRINSIC Vc_CONST To\nsimd_cast(From &&x, enable_if>::value> = nullarg)\n{\n return std::forward(x);\n}\n\n/**\n * A cast from nothing results in default-initialization of \\p To.\n *\n * This function can be useful in generic code where a parameter pack expands to nothing.\n *\n * \\returns A zero-initialized object of type \\p To.\n */\ntemplate Vc_INTRINSIC Vc_CONST To simd_cast() { return To(); }\n\n} // namespace Vc\n\n#endif // VC_COMMON_SIMD_CAST_H_\n" }, { "path": "3rdparty/Vc/Vc/common/simd_cast_caller.tcc", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_SIMD_CAST_CALLER_TCC_\n#define VC_COMMON_SIMD_CAST_CALLER_TCC_\n\n#include \"macros.h\"\nnamespace Vc_VERSIONED_NAMESPACE {\ntemplate \ntemplate \nVc_INTRINSIC SimdMaskArray::SimdMaskArray(\n const SimdMaskArray &x)\n : data(simd_cast(internal_data(x)))\n{\n}\ntemplate \ntemplate \nVc_INTRINSIC SimdMaskArray::SimdMaskArray(\n const SimdMaskArray &x)\n : data(simd_cast(internal_data(internal_data0(x)),\n internal_data(internal_data1(x))))\n{\n}\ntemplate \ntemplate \nVc_INTRINSIC SimdMaskArray::SimdMaskArray(\n const SimdMaskArray &x)\n : data(simd_cast(internal_data(internal_data0(internal_data0(x))),\n internal_data(internal_data1(internal_data0(x))),\n internal_data(internal_data0(internal_data1(x))),\n internal_data(internal_data1(internal_data1(x)))))\n{\n}\n// conversion from any Segment object (could be SimdMaskArray or Mask)\ntemplate \ntemplate \nVc_INTRINSIC SimdMaskArray::SimdMaskArray(\n Common::Segment &&x,\n enable_if::value == Size * Pieces>)\n : data(simd_cast(x.data))\n{\n}\n// conversion from Mask\ntemplate \ntemplate \nVc_INTRINSIC SimdMaskArray::SimdMaskArray(M k)\n : data(simd_cast(k))\n{\n}\n\n} // namespace Vc_VERSIONED_NAMESPACE\n\n#endif // VC_COMMON_SIMD_CAST_CALLER_TCC_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/simdarray.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_SIMDARRAY_H_\n#define VC_COMMON_SIMDARRAY_H_\n\n//#define Vc_DEBUG_SIMD_CAST 1\n//#define Vc_DEBUG_SORTED 1\n//#include \"../IO\"\n\n#include \n#include \n\n#include \"writemaskedvector.h\"\n#include \"simdarrayhelper.h\"\n#include \"simdmaskarray.h\"\n#include \"utility.h\"\n#include \"interleave.h\"\n#include \"indexsequence.h\"\n#include \"transpose.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n// select_best_vector_type {{{\nnamespace Common\n{\n/// \\addtogroup SimdArray\n/// @{\n/**\n * \\internal\n * Selects the best SIMD type out of a typelist to store N scalar values.\n */\ntemplate struct select_best_vector_type_impl;\n// last candidate; this one must work; assume it does:\ntemplate struct select_best_vector_type_impl {\n using type = T;\n};\n// check the next candidate; use it if N >= T::size(); recurse otherwise:\ntemplate \nstruct select_best_vector_type_impl {\n using type = typename std::conditional<\n (N < T::Size), typename select_best_vector_type_impl::type,\n T>::type;\n};\ntemplate \nstruct select_best_vector_type : select_best_vector_type_impl,\n#elif defined Vc_IMPL_AVX\n Vc::AVX::Vector,\n#endif\n#ifdef Vc_IMPL_SSE\n Vc::SSE::Vector,\n#endif\n Vc::Scalar::Vector> {\n};\n/// @}\n} // namespace Common\n// }}}\n// internal namespace (product & sum helper) {{{1\nnamespace internal\n{\ntemplate T Vc_INTRINSIC Vc_PURE product_helper_(const T &l, const T &r) { return l * r; }\ntemplate T Vc_INTRINSIC Vc_PURE sum_helper_(const T &l, const T &r) { return l + r; }\n} // namespace internal\n\n// min & max declarations {{{1\ntemplate \ninline fixed_size_simd min(const SimdArray &x,\n const SimdArray &y);\ntemplate \ninline fixed_size_simd max(const SimdArray &x,\n const SimdArray &y);\n\n// SimdArray class {{{1\n/// \\addtogroup SimdArray\n/// @{\n\n// atomic SimdArray {{{1\n#define Vc_CURRENT_CLASS_NAME SimdArray\n/**\\internal\n * Specialization of `SimdArray` for the case where `N ==\n * VectorSize`.\n *\n * This is specialized for implementation purposes: Since the general implementation uses\n * two SimdArray data members it recurses over different SimdArray instantiations. The\n * recursion is ended by this specialization, which has a single \\p VectorType_ data\n * member to which all functions are forwarded more or less directly.\n */\ntemplate \nclass SimdArray\n{\n static_assert(std::is_same::value || std::is_same::value ||\n std::is_same::value ||\n std::is_same::value ||\n std::is_same::value ||\n std::is_same::value,\n \"SimdArray may only be used with T = { double, float, int32_t, uint32_t, \"\n \"int16_t, uint16_t }\");\n static_assert(\n std::is_same::type>::value &&\n VectorType_::size() == N,\n \"ERROR: leave the third and fourth template parameters with their defaults. They \"\n \"are implementation details.\");\n\npublic:\n static constexpr bool is_atomic = true;\n using VectorType = VectorType_;\n using vector_type = VectorType;\n using storage_type = vector_type;\n using vectorentry_type = typename vector_type::VectorEntryType;\n using value_type = T;\n using mask_type = fixed_size_simd_mask;\n using index_type = fixed_size_simd;\n static constexpr std::size_t size() { return N; }\n using Mask = mask_type;\n using MaskType = Mask;\n using MaskArgument = const MaskType &;\n using VectorEntryType = vectorentry_type;\n using EntryType = value_type;\n using IndexType = index_type;\n using AsArg = const SimdArray &;\n using reference = Detail::ElementReference;\n static constexpr std::size_t Size = size();\n static constexpr std::size_t MemoryAlignment = storage_type::MemoryAlignment;\n\n // zero init\n Vc_INTRINSIC SimdArray() = default;\n\n // default copy ctor/operator\n Vc_INTRINSIC SimdArray(const SimdArray &) = default;\n Vc_INTRINSIC SimdArray(SimdArray &&) = default;\n Vc_INTRINSIC SimdArray &operator=(const SimdArray &) = default;\n\n // broadcast\n Vc_INTRINSIC SimdArray(const value_type &a) : data(a) {}\n Vc_INTRINSIC SimdArray(value_type &a) : data(a) {}\n Vc_INTRINSIC SimdArray(value_type &&a) : data(a) {}\n template <\n typename U,\n typename = enable_if::value && !std::is_same::value>>\n Vc_INTRINSIC SimdArray(U a)\n : SimdArray(static_cast(a))\n {\n }\n\n // implicit casts\n template >\n Vc_INTRINSIC SimdArray(const SimdArray &x)\n : data(simd_cast(internal_data(x)))\n {\n }\n template V::Size && N <= 2 * V::Size)>,\n class = U>\n Vc_INTRINSIC SimdArray(const SimdArray &x)\n : data(simd_cast(internal_data(internal_data0(x)),\n internal_data(internal_data1(x))))\n {\n }\n template 2 * V::Size && N <= 4 * V::Size)>,\n class = U, class = U>\n Vc_INTRINSIC SimdArray(const SimdArray &x)\n : data(simd_cast(internal_data(internal_data0(internal_data0(x))),\n internal_data(internal_data1(internal_data0(x))),\n internal_data(internal_data0(internal_data1(x))),\n internal_data(internal_data1(internal_data1(x)))))\n {\n }\n\n template \n Vc_INTRINSIC SimdArray(Common::Segment &&x)\n : data(simd_cast(x.data))\n {\n }\n\n Vc_INTRINSIC SimdArray(const std::initializer_list &init)\n : data(init.begin(), Vc::Unaligned)\n {\n Vc_ASSERT(init.size() == size());\n }\n\n // implicit conversion from underlying vector_type\n template <\n typename V,\n typename = enable_if::value && !Traits::isSimdArray::value>>\n Vc_INTRINSIC SimdArray(const V &x)\n : data(simd_cast(x))\n {\n }\n\n // implicit conversion to Vector for if Vector::size() == N and\n // T implicitly convertible to U\n template ::value && Vector::Size == N &&\n !std::is_same>::value>>\n Vc_INTRINSIC operator Vector() const\n {\n return simd_cast>(data);\n }\n operator fixed_size_simd &()\n {\n return static_cast &>(*this);\n }\n operator const fixed_size_simd &() const\n {\n return static_cast &>(*this);\n }\n\n#include \"gatherinterface.h\"\n#include \"scatterinterface.h\"\n\n explicit Vc_INTRINSIC SimdArray(VectorSpecialInitializerZero) : data() {}\n explicit Vc_INTRINSIC SimdArray(VectorSpecialInitializerOne o) : data(o) {}\n explicit Vc_INTRINSIC SimdArray(VectorSpecialInitializerIndexesFromZero i) : data(i)\n {\n }\n template \n explicit Vc_INTRINSIC SimdArray(\n Common::AddOffset)\n : data(Vc::IndexesFromZero)\n {\n data += value_type(Offset);\n }\n\n Vc_INTRINSIC void setZero() { data.setZero(); }\n Vc_INTRINSIC void setZero(mask_type k) { data.setZero(internal_data(k)); }\n Vc_INTRINSIC void setZeroInverted() { data.setZeroInverted(); }\n Vc_INTRINSIC void setZeroInverted(mask_type k) { data.setZeroInverted(internal_data(k)); }\n\n Vc_INTRINSIC void setQnan() { data.setQnan(); }\n Vc_INTRINSIC void setQnan(mask_type m) { data.setQnan(internal_data(m)); }\n\n // internal: execute specified Operation\n template \n static Vc_INTRINSIC fixed_size_simd fromOperation(Op op, Args &&... args)\n {\n fixed_size_simd r;\n Common::unpackArgumentsAuto(op, r.data, std::forward(args)...);\n return r;\n }\n\n template \n static Vc_INTRINSIC void callOperation(Op op, Args &&... args)\n {\n Common::unpackArgumentsAuto(op, nullptr, std::forward(args)...);\n }\n\n static Vc_INTRINSIC fixed_size_simd Zero()\n {\n return SimdArray(Vc::Zero);\n }\n static Vc_INTRINSIC fixed_size_simd One()\n {\n return SimdArray(Vc::One);\n }\n static Vc_INTRINSIC fixed_size_simd IndexesFromZero()\n {\n return SimdArray(Vc::IndexesFromZero);\n }\n static Vc_INTRINSIC fixed_size_simd Random()\n {\n return fromOperation(Common::Operations::random());\n }\n\n // load ctor\n template ::value &&\n Traits::is_load_store_flag::value>>\n explicit Vc_INTRINSIC SimdArray(const U *mem, Flags f = {}) : data(mem, f)\n {\n }\n\n template Vc_INTRINSIC void load(Args &&... args)\n {\n data.load(std::forward(args)...);\n }\n\n template Vc_INTRINSIC void store(Args &&... args) const\n {\n data.store(std::forward(args)...);\n }\n\n Vc_INTRINSIC mask_type operator!() const\n {\n return {private_init, !data};\n }\n\n Vc_INTRINSIC fixed_size_simd operator-() const\n {\n return {private_init, -data};\n }\n\n /// Returns a copy of itself\n Vc_INTRINSIC fixed_size_simd operator+() const { return *this; }\n\n Vc_INTRINSIC fixed_size_simd operator~() const\n {\n return {private_init, ~data};\n }\n\n template ::value && std::is_integral::value>>\n Vc_INTRINSIC Vc_CONST fixed_size_simd operator<<(U x) const\n {\n return {private_init, data << x};\n }\n template ::value && std::is_integral::value>>\n Vc_INTRINSIC fixed_size_simd &operator<<=(U x)\n {\n data <<= x;\n return *this;\n }\n template ::value && std::is_integral::value>>\n Vc_INTRINSIC Vc_CONST fixed_size_simd operator>>(U x) const\n {\n return {private_init, data >> x};\n }\n template ::value && std::is_integral::value>>\n Vc_INTRINSIC fixed_size_simd &operator>>=(U x)\n {\n data >>= x;\n return *this;\n }\n\n#define Vc_BINARY_OPERATOR_(op) \\\n Vc_INTRINSIC fixed_size_simd &operator op##=(const SimdArray &rhs) \\\n { \\\n data op## = rhs.data; \\\n return *this; \\\n }\n Vc_ALL_ARITHMETICS(Vc_BINARY_OPERATOR_);\n Vc_ALL_BINARY(Vc_BINARY_OPERATOR_);\n Vc_ALL_SHIFTS(Vc_BINARY_OPERATOR_);\n#undef Vc_BINARY_OPERATOR_\n\n /// \\copydoc Vector::isNegative\n Vc_DEPRECATED(\"use isnegative(x) instead\") Vc_INTRINSIC MaskType isNegative() const\n {\n return {private_init, isnegative(data)};\n }\n\nprivate:\n friend reference;\n Vc_INTRINSIC static value_type get(const SimdArray &o, int i) noexcept\n {\n return o.data[i];\n }\n template \n Vc_INTRINSIC static void set(SimdArray &o, int i, U &&v) noexcept(\n noexcept(std::declval() = v))\n {\n o.data[i] = v;\n }\n\npublic:\n /**\n * \\note the returned object models the concept of a reference and\n * as such it can exist longer than the data it is referencing.\n * \\note to avoid lifetime issues, we strongly advice not to store\n * any reference objects.\n */\n Vc_INTRINSIC reference operator[](size_t i) noexcept\n {\n static_assert(noexcept(reference{std::declval(), int()}), \"\");\n return {*this, int(i)};\n }\n Vc_INTRINSIC value_type operator[](size_t i) const noexcept\n {\n return get(*this, int(i));\n }\n\n Vc_INTRINSIC Common::WriteMaskedVector operator()(const mask_type &k)\n {\n return {*this, k};\n }\n\n Vc_INTRINSIC void assign(const SimdArray &v, const mask_type &k)\n {\n data.assign(v.data, internal_data(k));\n }\n\n // reductions ////////////////////////////////////////////////////////\n#define Vc_REDUCTION_FUNCTION_(name_) \\\n Vc_INTRINSIC Vc_PURE value_type name_() const { return data.name_(); } \\\n Vc_INTRINSIC Vc_PURE value_type name_(mask_type mask) const \\\n { \\\n return data.name_(internal_data(mask)); \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\n Vc_REDUCTION_FUNCTION_(min);\n Vc_REDUCTION_FUNCTION_(max);\n Vc_REDUCTION_FUNCTION_(product);\n Vc_REDUCTION_FUNCTION_(sum);\n#undef Vc_REDUCTION_FUNCTION_\n Vc_INTRINSIC Vc_PURE fixed_size_simd partialSum() const\n {\n return {private_init, data.partialSum()};\n }\n\n template Vc_INTRINSIC fixed_size_simd apply(F &&f) const\n {\n return {private_init, data.apply(std::forward(f))};\n }\n template Vc_INTRINSIC fixed_size_simd apply(F &&f, const mask_type &k) const\n {\n return {private_init, data.apply(std::forward(f), k)};\n }\n\n Vc_INTRINSIC fixed_size_simd shifted(int amount) const\n {\n return {private_init, data.shifted(amount)};\n }\n\n template \n Vc_INTRINSIC fixed_size_simd shifted(int amount, const SimdArray &shiftIn)\n const\n {\n return {private_init, data.shifted(amount, simd_cast(shiftIn))};\n }\n\n Vc_INTRINSIC fixed_size_simd rotated(int amount) const\n {\n return {private_init, data.rotated(amount)};\n }\n\n /// \\copydoc Vector::exponent\n Vc_DEPRECATED(\"use exponent(x) instead\") Vc_INTRINSIC fixed_size_simd exponent() const\n {\n return {private_init, exponent(data)};\n }\n\n Vc_INTRINSIC fixed_size_simd interleaveLow(SimdArray x) const\n {\n return {private_init, data.interleaveLow(x.data)};\n }\n Vc_INTRINSIC fixed_size_simd interleaveHigh(SimdArray x) const\n {\n return {private_init, data.interleaveHigh(x.data)};\n }\n\n Vc_INTRINSIC fixed_size_simd reversed() const\n {\n return {private_init, data.reversed()};\n }\n\n Vc_INTRINSIC fixed_size_simd sorted() const\n {\n return {private_init, data.sorted()};\n }\n\n template ()(std::size_t())),\n class = enable_if::value>>\n Vc_INTRINSIC SimdArray(const G &gen) : data(gen)\n {\n }\n template static Vc_INTRINSIC fixed_size_simd generate(const G &gen)\n {\n return {private_init, VectorType::generate(gen)};\n }\n\n Vc_DEPRECATED(\"use copysign(x, y) instead\")\n Vc_INTRINSIC fixed_size_simd copySign(const SimdArray &x) const\n {\n return {private_init, Vc::copysign(data, x.data)};\n }\n\n friend VectorType &internal_data<>(SimdArray &x);\n friend const VectorType &internal_data<>(const SimdArray &x);\n\n /// \\internal\n Vc_INTRINSIC SimdArray(private_init_t, VectorType &&x) : data(std::move(x)) {}\n\n Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(storage_type));\n\nprivate:\n // The alignas attribute attached to the class declaration above is ignored by ICC\n // 17.0.0 (at least). So just move the alignas attribute down here where it works for\n // all compilers.\n alignas(static_cast(\n Common::BoundedAlignment::value * sizeof(VectorType_) /\n VectorType_::size()>::value)) storage_type data;\n};\ntemplate constexpr std::size_t SimdArray::Size;\ntemplate \nconstexpr std::size_t SimdArray::MemoryAlignment;\ntemplate \n#ifndef Vc_MSVC\nVc_INTRINSIC\n#endif\nVectorType &internal_data(SimdArray &x)\n{\n return x.data;\n}\ntemplate \n#ifndef Vc_MSVC\nVc_INTRINSIC\n#endif\nconst VectorType &internal_data(const SimdArray &x)\n{\n return x.data;\n}\n\n// unwrap {{{2\ntemplate Vc_INTRINSIC T unwrap(const T &x) { return x; }\n\ntemplate \nVc_INTRINSIC V unwrap(const SimdArray &x)\n{\n return internal_data(x);\n}\n\ntemplate \nVc_INTRINSIC auto unwrap(const Common::Segment &x)\n -> decltype(x.to_fixed_size())\n{\n return unwrap(x.to_fixed_size());\n}\n\n// gatherImplementation {{{2\ntemplate \ntemplate \nVc_INTRINSIC void SimdArray::gatherImplementation(\n const Common::GatherArguments &args)\n{\n data.gather(Common::make_gather(args.address, unwrap(args.indexes)));\n}\ntemplate \ntemplate \nVc_INTRINSIC void SimdArray::gatherImplementation(\n const Common::GatherArguments &args, MaskArgument mask)\n{\n data.gather(Common::make_gather(args.address, unwrap(args.indexes)),\n mask);\n}\n\n// scatterImplementation {{{2\ntemplate \ntemplate \ninline void SimdArray::scatterImplementation(MT *mem,\n IT &&indexes) const\n{\n data.scatter(mem, unwrap(std::forward(indexes)));\n}\ntemplate \ntemplate \ninline void SimdArray::scatterImplementation(MT *mem,\n IT &&indexes,\n MaskArgument mask) const\n{\n data.scatter(mem, unwrap(std::forward(indexes)), mask);\n}\n\n// generic SimdArray {{{1\n/**\n * Data-parallel arithmetic type with user-defined number of elements.\n *\n * \\tparam T The type of the vector's elements. The supported types currently are limited\n * to the types supported by Vc::Vector.\n *\n * \\tparam N The number of elements to store and process concurrently. You can choose an\n * arbitrary number, though not every number is a good idea.\n * Generally, a power of two value or the sum of two power of two values might\n * work efficiently, though this depends a lot on the target system.\n *\n * \\tparam V Don't change the default value unless you really know what you are doing.\n * This type is set to the underlying native Vc::Vector type used in the\n * implementation of the type.\n * Having it as part of the type name guards against some cases of ODR\n * violations (i.e. linking incompatible translation units / libraries).\n *\n * \\tparam Wt Don't ever change the default value.\n * This parameter is an unfortunate implementation detail shining through.\n *\n * \\warning Choosing \\p N too large (what “too large” means depends on the target) will\n * result in excessive compilation times and high (or too high) register\n * pressure, thus potentially negating the improvement from concurrent execution.\n * As a rule of thumb, keep \\p N less or equal to `2 * float_v::size()`.\n *\n * \\warning A special portability concern arises from a current limitation in the MIC\n * implementation (Intel Knights Corner), where SimdArray types with \\p T = \\p\n * (u)short require an \\p N either less than short_v::size() or a multiple of\n * short_v::size().\n *\n * \\headerfile simdarray.h \n */\ntemplate class SimdArray\n{\n static_assert(std::is_same::value ||\n std::is_same::value ||\n std::is_same::value ||\n std::is_same::value ||\n std::is_same::value ||\n std::is_same::value, \"SimdArray may only be used with T = { double, float, int32_t, uint32_t, int16_t, uint16_t }\");\n static_assert(\n std::is_same::type>::value &&\n V::size() == Wt,\n \"ERROR: leave the third and fourth template parameters with their defaults. They \"\n \"are implementation details.\");\n static_assert(\n // either the EntryType and VectorEntryType of the main V are equal\n std::is_same::value ||\n // or N is a multiple of V::size()\n (N % V::size() == 0),\n \"SimdArray<(un)signed short, N> on MIC only works correctly for N = k * \"\n \"MIC::(u)short_v::size(), i.e. k * 16.\");\n\n using my_traits = SimdArrayTraits;\n static constexpr std::size_t N0 = my_traits::N0;\n static constexpr std::size_t N1 = my_traits::N1;\n using Split = Common::Split;\n template using CArray = U[K];\n\npublic:\n static constexpr bool is_atomic = false;\n using storage_type0 = typename my_traits::storage_type0;\n using storage_type1 = typename my_traits::storage_type1;\n static_assert(storage_type0::size() == N0, \"\");\n\n /**\\internal\n * This type reveals the implementation-specific type used for the data member.\n */\n using vector_type = V;\n using vectorentry_type = typename storage_type0::vectorentry_type;\n typedef vectorentry_type alias_type Vc_MAY_ALIAS;\n\n /// The type of the elements (i.e.\\ \\p T)\n using value_type = T;\n\n /// The type of the mask used for masked operations and returned from comparisons.\n using mask_type = fixed_size_simd_mask;\n\n /// The type of the vector used for indexes in gather and scatter operations.\n using index_type = fixed_size_simd;\n\n /**\n * Returns \\p N, the number of scalar components in an object of this type.\n *\n * The size of the SimdArray, i.e. the number of scalar elements in the vector. In\n * contrast to Vector::size() you have control over this value via the \\p N template\n * parameter of the SimdArray class template.\n *\n * \\returns The number of scalar values stored and manipulated concurrently by objects\n * of this type.\n */\n static constexpr std::size_t size() { return N; }\n\n /// \\copydoc mask_type\n using Mask = mask_type;\n /// \\copydoc mask_type\n using MaskType = Mask;\n using MaskArgument = const MaskType &;\n using VectorEntryType = vectorentry_type;\n /// \\copydoc value_type\n using EntryType = value_type;\n /// \\copydoc index_type\n using IndexType = index_type;\n using AsArg = const SimdArray &;\n\n using reference = Detail::ElementReference;\n\n ///\\copydoc Vector::MemoryAlignment\n static constexpr std::size_t MemoryAlignment =\n storage_type0::MemoryAlignment > storage_type1::MemoryAlignment\n ? storage_type0::MemoryAlignment\n : storage_type1::MemoryAlignment;\n\n /// \\name Generators\n ///@{\n\n ///\\copybrief Vector::Zero\n static Vc_INTRINSIC fixed_size_simd Zero()\n {\n return SimdArray(Vc::Zero);\n }\n\n ///\\copybrief Vector::One\n static Vc_INTRINSIC fixed_size_simd One()\n {\n return SimdArray(Vc::One);\n }\n\n ///\\copybrief Vector::IndexesFromZero\n static Vc_INTRINSIC fixed_size_simd IndexesFromZero()\n {\n return SimdArray(Vc::IndexesFromZero);\n }\n\n ///\\copydoc Vector::Random\n static Vc_INTRINSIC fixed_size_simd Random()\n {\n return fromOperation(Common::Operations::random());\n }\n\n template ()(std::size_t())),\n class = enable_if::value>>\n Vc_INTRINSIC SimdArray(const G &gen)\n : data0(gen), data1([&](std::size_t i) { return gen(i + storage_type0::size()); })\n {\n }\n\n ///\\copybrief Vector::generate\n template static Vc_INTRINSIC fixed_size_simd generate(const G &gen) // {{{2\n {\n auto tmp = storage_type0::generate(gen); // GCC bug: the order of evaluation in\n // an initializer list is well-defined\n // (front to back), but GCC 4.8 doesn't\n // implement this correctly. Therefore\n // we enforce correct order.\n return {std::move(tmp),\n storage_type1::generate([&](std::size_t i) { return gen(i + N0); })};\n }\n ///@}\n\n /// \\name Compile-Time Constant Initialization\n ///@{\n\n ///\\copydoc Vector::Vector()\n SimdArray() = default;\n ///@}\n\n /// \\name Conversion/Broadcast Constructors\n ///@{\n\n ///\\copydoc Vector::Vector(EntryType)\n Vc_INTRINSIC SimdArray(value_type a) : data0(a), data1(a) {}\n template <\n typename U,\n typename = enable_if::value && !std::is_same::value>>\n SimdArray(U a)\n : SimdArray(static_cast(a))\n {\n }\n ///@}\n\n // default copy ctor/operator\n SimdArray(const SimdArray &) = default;\n SimdArray(SimdArray &&) = default;\n SimdArray &operator=(const SimdArray &) = default;\n\n // load ctor\n template ::value &&\n Traits::is_load_store_flag::value>>\n explicit Vc_INTRINSIC SimdArray(const U *mem, Flags f = {})\n : data0(mem, f), data1(mem + storage_type0::size(), f)\n {\n }\n\n// MSVC does overload resolution differently and takes the const U *mem overload (I hope)\n#ifndef Vc_MSVC\n /**\\internal\n * Load from a C-array. This is basically the same function as the load constructor\n * above, except that the forwarding reference overload would steal the deal and the\n * constructor above doesn't get called. This overload is required to enable loads\n * from C-arrays.\n */\n template ::value &&\n Traits::is_load_store_flag::value>>\n explicit Vc_INTRINSIC SimdArray(CArray &mem, Flags f = {})\n : data0(&mem[0], f), data1(&mem[storage_type0::size()], f)\n {\n }\n /**\\internal\n * Const overload of the above.\n */\n template ::value &&\n Traits::is_load_store_flag::value>>\n explicit Vc_INTRINSIC SimdArray(const CArray &mem, Flags f = {})\n : data0(&mem[0], f), data1(&mem[storage_type0::size()], f)\n {\n }\n#endif\n\n // initializer list\n Vc_INTRINSIC SimdArray(const std::initializer_list &init)\n : data0(init.begin(), Vc::Unaligned)\n , data1(init.begin() + storage_type0::size(), Vc::Unaligned)\n {\n Vc_ASSERT(init.size() == size());\n }\n\n#include \"gatherinterface.h\"\n#include \"scatterinterface.h\"\n\n explicit Vc_INTRINSIC SimdArray(VectorSpecialInitializerZero) : data0(), data1() {}\n explicit Vc_INTRINSIC SimdArray(VectorSpecialInitializerOne o) : data0(o), data1(o) {}\n explicit Vc_INTRINSIC SimdArray(VectorSpecialInitializerIndexesFromZero i)\n : data0(i)\n , data1(Common::AddOffset())\n {\n }\n template \n explicit Vc_INTRINSIC SimdArray(\n Common::AddOffset i)\n : data0(i)\n , data1(Common::AddOffset())\n {\n }\n\n // explicit casts\n template ::value &&\n Traits::simd_vector_size::value == N &&\n !(std::is_convertible, T>::value &&\n Traits::isSimdArray::value))>>\n Vc_INTRINSIC explicit SimdArray(W &&x) : data0(Split::lo(x)), data1(Split::hi(x))\n {\n }\n\n // implicit casts\n template ::value &&\n Traits::simd_vector_size::value == N &&\n std::is_convertible, T>::value)>,\n class = W>\n Vc_INTRINSIC SimdArray(W &&x) : data0(Split::lo(x)), data1(Split::hi(x))\n {\n }\n\n template \n Vc_INTRINSIC SimdArray(Common::Segment &&x)\n : data0(Common::Segment{x.data})\n , data1(Common::Segment{x.data})\n {\n }\n\n // implicit conversion to Vector for if Vector::size() == N and\n // T implicitly convertible to U\n template ::value && Vector::Size == N &&\n !std::is_same>::value>>\n operator Vector() const\n {\n auto r = simd_cast>(data0, data1);\n return r;\n }\n Vc_INTRINSIC operator fixed_size_simd &()\n {\n return static_cast &>(*this);\n }\n Vc_INTRINSIC operator const fixed_size_simd &() const\n {\n return static_cast &>(*this);\n }\n\n //////////////////// other functions ///////////////\n\n Vc_INTRINSIC void setZero()\n {\n data0.setZero();\n data1.setZero();\n }\n Vc_INTRINSIC void setZero(const mask_type &k)\n {\n data0.setZero(Split::lo(k));\n data1.setZero(Split::hi(k));\n }\n Vc_INTRINSIC void setZeroInverted()\n {\n data0.setZeroInverted();\n data1.setZeroInverted();\n }\n Vc_INTRINSIC void setZeroInverted(const mask_type &k)\n {\n data0.setZeroInverted(Split::lo(k));\n data1.setZeroInverted(Split::hi(k));\n }\n\n\n Vc_INTRINSIC void setQnan() {\n data0.setQnan();\n data1.setQnan();\n }\n Vc_INTRINSIC void setQnan(const mask_type &m) {\n data0.setQnan(Split::lo(m));\n data1.setQnan(Split::hi(m));\n }\n\n ///\\internal execute specified Operation\n template \n static Vc_INTRINSIC fixed_size_simd fromOperation(Op op, Args &&... args)\n {\n fixed_size_simd r = {\n storage_type0::fromOperation(op, Split::lo(args)...), // no forward here - it\n // could move and thus\n // break the next line\n storage_type1::fromOperation(op, Split::hi(std::forward(args))...)};\n return r;\n }\n\n ///\\internal\n template \n static Vc_INTRINSIC void callOperation(Op op, Args &&... args)\n {\n storage_type0::callOperation(op, Split::lo(args)...);\n storage_type1::callOperation(op, Split::hi(std::forward(args))...);\n }\n\n\n template Vc_INTRINSIC void load(const U *mem, Args &&... args)\n {\n data0.load(mem, Split::lo(args)...); // no forward here - it could move and thus\n // break the next line\n data1.load(mem + storage_type0::size(), Split::hi(std::forward(args))...);\n }\n\n template Vc_INTRINSIC void store(U *mem, Args &&... args) const\n {\n data0.store(mem, Split::lo(args)...); // no forward here - it could move and thus\n // break the next line\n data1.store(mem + storage_type0::size(), Split::hi(std::forward(args))...);\n }\n\n Vc_INTRINSIC mask_type operator!() const\n {\n return {!data0, !data1};\n }\n\n Vc_INTRINSIC fixed_size_simd operator-() const\n {\n return {-data0, -data1};\n }\n\n /// Returns a copy of itself\n Vc_INTRINSIC fixed_size_simd operator+() const { return *this; }\n\n Vc_INTRINSIC fixed_size_simd operator~() const\n {\n return {~data0, ~data1};\n }\n\n // left/right shift operators {{{2\n template ::value && std::is_integral::value>>\n Vc_INTRINSIC Vc_CONST fixed_size_simd operator<<(U x) const\n {\n return {data0 << x, data1 << x};\n }\n template ::value && std::is_integral::value>>\n Vc_INTRINSIC fixed_size_simd &operator<<=(U x)\n {\n data0 <<= x;\n data1 <<= x;\n return *this;\n }\n template ::value && std::is_integral::value>>\n Vc_INTRINSIC Vc_CONST fixed_size_simd operator>>(U x) const\n {\n return {data0 >> x, data1 >> x};\n }\n template ::value && std::is_integral::value>>\n Vc_INTRINSIC fixed_size_simd &operator>>=(U x)\n {\n data0 >>= x;\n data1 >>= x;\n return *this;\n }\n\n // binary operators {{{2\n#define Vc_BINARY_OPERATOR_(op) \\\n Vc_INTRINSIC fixed_size_simd &operator op##=(const SimdArray &rhs) \\\n { \\\n data0 op## = rhs.data0; \\\n data1 op## = rhs.data1; \\\n return *this; \\\n }\n Vc_ALL_ARITHMETICS(Vc_BINARY_OPERATOR_);\n Vc_ALL_BINARY(Vc_BINARY_OPERATOR_);\n Vc_ALL_SHIFTS(Vc_BINARY_OPERATOR_);\n#undef Vc_BINARY_OPERATOR_\n\n // operator[] {{{2\n /// \\name Scalar Subscript Operators\n ///@{\n\nprivate:\n friend reference;\n Vc_INTRINSIC static value_type get(const SimdArray &o, int i) noexcept\n {\n return reinterpret_cast(&o)[i];\n }\n template \n Vc_INTRINSIC static void set(SimdArray &o, int i, U &&v) noexcept(\n noexcept(std::declval() = v))\n {\n reinterpret_cast(&o)[i] = v;\n }\n\npublic:\n ///\\copydoc Vector::operator[](size_t)\n /**\n * \\note the returned object models the concept of a reference and\n * as such it can exist longer than the data it is referencing.\n * \\note to avoid lifetime issues, we strongly advice not to store\n * any reference objects.\n */\n Vc_INTRINSIC reference operator[](size_t i) noexcept\n {\n static_assert(noexcept(reference{std::declval(), int()}), \"\");\n return {*this, int(i)};\n }\n\n ///\\copydoc Vector::operator[](size_t) const\n Vc_INTRINSIC value_type operator[](size_t index) const noexcept\n {\n return get(*this, int(index));\n }\n ///@}\n\n // operator(){{{2\n ///\\copydoc Vector::operator()(MaskType)\n Vc_INTRINSIC Common::WriteMaskedVector operator()(\n const mask_type &mask)\n {\n return {*this, mask};\n }\n\n ///\\internal\n Vc_INTRINSIC void assign(const SimdArray &v, const mask_type &k) //{{{2\n {\n data0.assign(v.data0, internal_data0(k));\n data1.assign(v.data1, internal_data1(k));\n }\n\n // reductions {{{2\n#define Vc_REDUCTION_FUNCTION_(name_, binary_fun_, scalar_fun_) \\\nprivate: \\\n template \\\n Vc_INTRINSIC enable_if::value && \\\n storage_type0::Size == storage_type1::Size, \\\n value_type> name_##_impl() const \\\n { \\\n return binary_fun_(data0, data1).name_(); \\\n } \\\n \\\n template \\\n Vc_INTRINSIC enable_if::value && \\\n storage_type0::Size != storage_type1::Size, \\\n value_type> name_##_impl() const \\\n { \\\n return scalar_fun_(data0.name_(), data1.name_()); \\\n } \\\n \\\npublic: \\\n /**\\copybrief Vector::##name_ */ \\\n Vc_INTRINSIC value_type name_() const { return name_##_impl(); } \\\n /**\\copybrief Vector::##name_ */ \\\n Vc_INTRINSIC value_type name_(const mask_type &mask) const \\\n { \\\n if (Vc_IS_UNLIKELY(Split::lo(mask).isEmpty())) { \\\n return data1.name_(Split::hi(mask)); \\\n } else if (Vc_IS_UNLIKELY(Split::hi(mask).isEmpty())) { \\\n return data0.name_(Split::lo(mask)); \\\n } else { \\\n return scalar_fun_(data0.name_(Split::lo(mask)), \\\n data1.name_(Split::hi(mask))); \\\n } \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\n Vc_REDUCTION_FUNCTION_(min, Vc::min, std::min);\n Vc_REDUCTION_FUNCTION_(max, Vc::max, std::max);\n Vc_REDUCTION_FUNCTION_(product, internal::product_helper_, internal::product_helper_);\n Vc_REDUCTION_FUNCTION_(sum, internal::sum_helper_, internal::sum_helper_);\n#undef Vc_REDUCTION_FUNCTION_\n ///\\copybrief Vector::partialSum\n Vc_INTRINSIC Vc_PURE fixed_size_simd partialSum() const //{{{2\n {\n auto ps0 = data0.partialSum();\n auto tmp = data1;\n tmp[0] += ps0[data0.size() - 1];\n return {std::move(ps0), tmp.partialSum()};\n }\n\n // apply {{{2\n ///\\copybrief Vector::apply(F &&) const\n template inline fixed_size_simd apply(F &&f) const\n {\n return {data0.apply(f), data1.apply(f)};\n }\n ///\\copybrief Vector::apply(F &&, MaskType) const\n template \n inline fixed_size_simd apply(F &&f, const mask_type &k) const\n {\n return {data0.apply(f, Split::lo(k)), data1.apply(f, Split::hi(k))};\n }\n\n // shifted {{{2\n ///\\copybrief Vector::shifted(int) const\n inline fixed_size_simd shifted(int amount) const\n {\n constexpr int SSize = Size;\n constexpr int SSize0 = storage_type0::Size;\n constexpr int SSize1 = storage_type1::Size;\n if (amount == 0) {\n return *this;\n }\n if (amount < 0) {\n if (amount > -SSize0) {\n return {data0.shifted(amount), data1.shifted(amount, data0)};\n }\n if (amount == -SSize0) {\n return {storage_type0(0), simd_cast(data0)};\n }\n if (amount < -SSize0) {\n return {storage_type0(0), simd_cast(data0.shifted(\n amount + SSize0))};\n }\n return Zero();\n } else {\n if (amount >= SSize) {\n return Zero();\n } else if (amount >= SSize0) {\n return {\n simd_cast(data1).shifted(amount - SSize0),\n storage_type1(0)};\n } else if (amount >= SSize1) {\n return {data0.shifted(amount, data1), storage_type1(0)};\n } else {\n return {data0.shifted(amount, data1), data1.shifted(amount)};\n }\n }\n }\n\n template \n inline enable_if<\n !(std::is_same::value && // not bisectable\n N == NN),\n fixed_size_simd>\n shifted(int amount, const SimdArray &shiftIn) const\n {\n constexpr int SSize = Size;\n if (amount < 0) {\n return fixed_size_simd([&](int i) -> value_type {\n i += amount;\n if (i >= 0) {\n return operator[](i);\n } else if (i >= -SSize) {\n return shiftIn[i + SSize];\n }\n return 0;\n });\n }\n return fixed_size_simd([&](int i) -> value_type {\n i += amount;\n if (i < SSize) {\n return operator[](i);\n } else if (i < 2 * SSize) {\n return shiftIn[i - SSize];\n }\n return 0;\n });\n }\n\nprivate:\n // workaround for MSVC not understanding the simpler and shorter expression of the boolean\n // expression directly in the enable_if below\n template struct bisectable_shift\n : public std::integral_constant::value && // bisectable\n N == NN>\n {\n };\n\npublic:\n template \n inline fixed_size_simd shifted(\n enable_if::value, int> amount,\n const SimdArray &shiftIn) const\n {\n constexpr int SSize = Size;\n if (amount < 0) {\n if (amount > -static_cast(storage_type0::Size)) {\n return {data0.shifted(amount, internal_data1(shiftIn)),\n data1.shifted(amount, data0)};\n }\n if (amount == -static_cast(storage_type0::Size)) {\n return {storage_type0(internal_data1(shiftIn)), storage_type1(data0)};\n }\n if (amount > -SSize) {\n return {\n internal_data1(shiftIn)\n .shifted(amount + static_cast(storage_type0::Size), internal_data0(shiftIn)),\n data0.shifted(amount + static_cast(storage_type0::Size), internal_data1(shiftIn))};\n }\n if (amount == -SSize) {\n return shiftIn;\n }\n if (amount > -2 * SSize) {\n return shiftIn.shifted(amount + SSize);\n }\n }\n if (amount == 0) {\n return *this;\n }\n if (amount < static_cast(storage_type0::Size)) {\n return {data0.shifted(amount, data1),\n data1.shifted(amount, internal_data0(shiftIn))};\n }\n if (amount == static_cast(storage_type0::Size)) {\n return {storage_type0(data1), storage_type1(internal_data0(shiftIn))};\n }\n if (amount < SSize) {\n return {data1.shifted(amount - static_cast(storage_type0::Size), internal_data0(shiftIn)),\n internal_data0(shiftIn)\n .shifted(amount - static_cast(storage_type0::Size), internal_data1(shiftIn))};\n }\n if (amount == SSize) {\n return shiftIn;\n }\n if (amount < 2 * SSize) {\n return shiftIn.shifted(amount - SSize);\n }\n return Zero();\n }\n\n // rotated {{{2\n ///\\copybrief Vector::rotated\n Vc_INTRINSIC fixed_size_simd rotated(int amount) const\n {\n amount %= int(size());\n if (amount == 0) {\n return *this;\n } else if (amount < 0) {\n amount += size();\n }\n\n#ifdef Vc_MSVC\n // MSVC fails to find a SimdArray::shifted function with 2 arguments. So use store\n // ->\n // load to implement the function instead.\n alignas(MemoryAlignment) T tmp[N + data0.size()];\n data0.store(&tmp[0], Vc::Aligned);\n data1.store(&tmp[data0.size()], Vc::Aligned);\n data0.store(&tmp[N], Vc::Unaligned);\n fixed_size_simd r;\n r.data0.load(&tmp[amount], Vc::Unaligned);\n r.data1.load(&tmp[(amount + data0.size()) % size()], Vc::Unaligned);\n return r;\n#else\n auto &&d0cvtd = simd_cast(data0);\n auto &&d1cvtd = simd_cast(data1);\n constexpr int size0 = storage_type0::size();\n constexpr int size1 = storage_type1::size();\n\n if (amount == size0 && std::is_same::value) {\n return {std::move(d1cvtd), std::move(d0cvtd)};\n } else if (amount < size1) {\n return {data0.shifted(amount, d1cvtd), data1.shifted(amount, d0cvtd)};\n } else if (amount == size1) {\n return {data0.shifted(amount, d1cvtd), std::move(d0cvtd)};\n } else if (int(size()) - amount < size1) {\n return {data0.shifted(amount - int(size()), d1cvtd.shifted(size1 - size0)),\n data1.shifted(amount - int(size()), data0.shifted(size0 - size1))};\n } else if (int(size()) - amount == size1) {\n return {data0.shifted(-size1, d1cvtd.shifted(size1 - size0)),\n simd_cast(data0.shifted(size0 - size1))};\n } else if (amount <= size0) {\n return {data0.shifted(size1, d1cvtd).shifted(amount - size1, data0),\n simd_cast(data0.shifted(amount - size1))};\n } else {\n return {data0.shifted(size1, d1cvtd).shifted(amount - size1, data0),\n simd_cast(data0.shifted(amount - size1, d1cvtd))};\n }\n return *this;\n#endif\n }\n\n // interleaveLow/-High {{{2\n ///\\internal \\copydoc Vector::interleaveLow\n Vc_INTRINSIC fixed_size_simd interleaveLow(const SimdArray &x) const\n {\n // return data0[0], x.data0[0], data0[1], x.data0[1], ...\n return {data0.interleaveLow(x.data0),\n simd_cast(data0.interleaveHigh(x.data0))};\n }\n ///\\internal \\copydoc Vector::interleaveHigh\n Vc_INTRINSIC fixed_size_simd interleaveHigh(const SimdArray &x) const\n {\n return interleaveHighImpl(\n x,\n std::integral_constant());\n }\n\nprivate:\n ///\\internal\n Vc_INTRINSIC fixed_size_simd interleaveHighImpl(const SimdArray &x, std::true_type) const\n {\n return {data1.interleaveLow(x.data1), data1.interleaveHigh(x.data1)};\n }\n ///\\internal\n inline fixed_size_simd interleaveHighImpl(const SimdArray &x, std::false_type) const\n {\n return {data0.interleaveHigh(x.data0)\n .shifted(storage_type1::Size,\n simd_cast(data1.interleaveLow(x.data1))),\n data1.interleaveHigh(x.data1)};\n }\n\npublic:\n ///\\copybrief Vector::reversed\n inline fixed_size_simd reversed() const //{{{2\n {\n if (std::is_same::value) {\n return {simd_cast(data1).reversed(),\n simd_cast(data0).reversed()};\n } else {\n#ifdef Vc_MSVC\n // MSVC fails to find a SimdArray::shifted function with 2 arguments. So use\n // store\n // -> load to implement the function instead.\n alignas(MemoryAlignment) T tmp[N];\n data1.reversed().store(&tmp[0], Vc::Aligned);\n data0.reversed().store(&tmp[data1.size()], Vc::Unaligned);\n return fixed_size_simd{&tmp[0], Vc::Aligned};\n#else\n return {data0.shifted(storage_type1::Size, data1).reversed(),\n simd_cast(data0.reversed().shifted(\n storage_type0::Size - storage_type1::Size))};\n#endif\n }\n }\n ///\\copydoc Vector::sorted\n inline fixed_size_simd sorted() const //{{{2\n {\n return sortedImpl(\n std::integral_constant());\n }\n\n ///\\internal\n Vc_INTRINSIC fixed_size_simd sortedImpl(std::true_type) const\n {\n#ifdef Vc_DEBUG_SORTED\n std::cerr << \"-- \" << data0 << data1 << '\\n';\n#endif\n const auto a = data0.sorted();\n const auto b = data1.sorted().reversed();\n const auto lo = Vc::min(a, b);\n const auto hi = Vc::max(a, b);\n return {lo.sorted(), hi.sorted()};\n }\n\n ///\\internal\n Vc_INTRINSIC fixed_size_simd sortedImpl(std::false_type) const\n {\n using SortableArray =\n fixed_size_simd::value>;\n auto sortable = simd_cast(*this);\n for (std::size_t i = Size; i < SortableArray::Size; ++i) {\n using limits = std::numeric_limits;\n if (limits::has_infinity) {\n sortable[i] = limits::infinity();\n } else {\n sortable[i] = std::numeric_limits::max();\n }\n }\n return simd_cast>(sortable.sorted());\n\n /* The following implementation appears to be less efficient. But this may need further\n * work.\n const auto a = data0.sorted();\n const auto b = data1.sorted();\n#ifdef Vc_DEBUG_SORTED\n std::cerr << \"== \" << a << b << '\\n';\n#endif\n auto aIt = Vc::begin(a);\n auto bIt = Vc::begin(b);\n const auto aEnd = Vc::end(a);\n const auto bEnd = Vc::end(b);\n return SimdArray::generate([&](std::size_t) {\n if (aIt == aEnd) {\n return *(bIt++);\n }\n if (bIt == bEnd) {\n return *(aIt++);\n }\n if (*aIt < *bIt) {\n return *(aIt++);\n } else {\n return *(bIt++);\n }\n });\n */\n }\n\n /// \\name Deprecated Members\n ///@{\n\n ///\\copydoc size\n ///\\deprecated Use size() instead.\n static constexpr std::size_t Size = size();\n\n /// \\copydoc Vector::exponent\n Vc_DEPRECATED(\"use exponent(x) instead\")\n Vc_INTRINSIC fixed_size_simd exponent() const\n {\n return {exponent(data0), exponent(data1)};\n }\n\n /// \\copydoc Vector::isNegative\n Vc_DEPRECATED(\"use isnegative(x) instead\") Vc_INTRINSIC MaskType isNegative() const\n {\n return {isnegative(data0), isnegative(data1)};\n }\n\n ///\\copydoc Vector::copySign\n Vc_DEPRECATED(\"use copysign(x, y) instead\")\n Vc_INTRINSIC fixed_size_simd copySign(const SimdArray &x) const\n {\n return {Vc::copysign(data0, x.data0),\n Vc::copysign(data1, x.data1)};\n }\n ///@}\n\n // internal_data0/1 {{{2\n friend storage_type0 &internal_data0<>(SimdArray &x);\n friend storage_type1 &internal_data1<>(SimdArray &x);\n friend const storage_type0 &internal_data0<>(const SimdArray &x);\n friend const storage_type1 &internal_data1<>(const SimdArray &x);\n\n /// \\internal\n Vc_INTRINSIC SimdArray(storage_type0 &&x, storage_type1 &&y) //{{{2\n : data0(std::move(x)), data1(std::move(y))\n {\n }\n\n Vc_FREE_STORE_OPERATORS_ALIGNED(alignof(storage_type0));\n\nprivate: //{{{2\n // The alignas attribute attached to the class declaration above is ignored by ICC\n // 17.0.0 (at least). So just move the alignas attribute down here where it works for\n // all compilers.\n alignas(static_cast(\n Common::BoundedAlignment::value * sizeof(V) /\n V::size()>::value)) storage_type0 data0;\n storage_type1 data1;\n};\n#undef Vc_CURRENT_CLASS_NAME\ntemplate \nconstexpr std::size_t SimdArray::Size;\ntemplate \nconstexpr std::size_t SimdArray::MemoryAlignment;\n\n// gatherImplementation {{{2\ntemplate \ntemplate \ninline void SimdArray::gatherImplementation(\n const Common::GatherArguments &args)\n{\n data0.gather(Common::make_gather(\n args.address, Split::lo(Common::Operations::gather(), args.indexes)));\n data1.gather(Common::make_gather(\n args.address, Split::hi(Common::Operations::gather(), args.indexes)));\n}\ntemplate \ntemplate \ninline void SimdArray::gatherImplementation(\n const Common::GatherArguments &args, MaskArgument mask)\n{\n data0.gather(Common::make_gather(\n args.address, Split::lo(Common::Operations::gather(), args.indexes)),\n Split::lo(mask));\n data1.gather(Common::make_gather(\n args.address, Split::hi(Common::Operations::gather(), args.indexes)),\n Split::hi(mask));\n}\n\n// scatterImplementation {{{2\ntemplate \ntemplate \ninline void SimdArray::scatterImplementation(MT *mem,\n IT &&indexes) const\n{\n data0.scatter(mem, Split::lo(Common::Operations::gather(),\n indexes)); // don't forward indexes - it could move and\n // thus break the next line\n data1.scatter(mem, Split::hi(Common::Operations::gather(), std::forward(indexes)));\n}\ntemplate \ntemplate \ninline void SimdArray::scatterImplementation(MT *mem,\n IT &&indexes, MaskArgument mask) const\n{\n data0.scatter(mem, Split::lo(Common::Operations::gather(), indexes),\n Split::lo(mask)); // don't forward indexes - it could move and\n // thus break the next line\n data1.scatter(mem, Split::hi(Common::Operations::gather(), std::forward(indexes)),\n Split::hi(mask));\n}\n\n// internal_data0/1 (SimdArray) {{{1\n///\\internal Returns the first data member of a generic SimdArray\ntemplate \n#ifndef Vc_MSVC\nVc_INTRINSIC\n#endif\ntypename SimdArrayTraits::storage_type0 &internal_data0(\n SimdArray &x)\n{\n return x.data0;\n}\n///\\internal Returns the second data member of a generic SimdArray\ntemplate \n#ifndef Vc_MSVC\nVc_INTRINSIC\n#endif\ntypename SimdArrayTraits::storage_type1 &internal_data1(\n SimdArray &x)\n{\n return x.data1;\n}\n///\\internal Returns the first data member of a generic SimdArray (const overload)\ntemplate \n#ifndef Vc_MSVC\nVc_INTRINSIC\n#endif\nconst typename SimdArrayTraits::storage_type0 &internal_data0(\n const SimdArray &x)\n{\n return x.data0;\n}\n///\\internal Returns the second data member of a generic SimdArray (const overload)\ntemplate \n#ifndef Vc_MSVC\nVc_INTRINSIC\n#endif\nconst typename SimdArrayTraits::storage_type1 &internal_data1(\n const SimdArray &x)\n{\n return x.data1;\n}\n\n// MSVC workaround for SimdArray(storage_type0, storage_type1) ctor{{{1\n// MSVC sometimes stores x to data1. By first broadcasting 0 and then assigning y\n// in the body the bug is supressed.\n#if defined Vc_MSVC && defined Vc_IMPL_SSE && !defined Vc_IMPL_AVX\ntemplate <>\nVc_INTRINSIC SimdArray::SimdArray(fixed_size_simd &&x,\n fixed_size_simd &&y)\n : data0(x), data1(0)\n{\n data1 = y;\n}\n#endif\n\n// binary operators {{{\nnamespace Detail\n{\n#define Vc_FIXED_OP(op) \\\n template ::is_atomic>::type> \\\n Vc_INTRINSIC fixed_size_simd operator op(const fixed_size_simd &a, \\\n const fixed_size_simd &b) \\\n { \\\n return {private_init, internal_data(a) op internal_data(b)}; \\\n } \\\n template ::is_atomic>::type, \\\n class = T> \\\n Vc_INTRINSIC fixed_size_simd operator op(const fixed_size_simd &a, \\\n const fixed_size_simd &b) \\\n { \\\n return {internal_data0(a) op internal_data0(b), \\\n internal_data1(a) op internal_data1(b)}; \\\n }\nVc_ALL_ARITHMETICS(Vc_FIXED_OP);\nVc_ALL_BINARY(Vc_FIXED_OP);\nVc_ALL_SHIFTS(Vc_FIXED_OP);\n#undef Vc_FIXED_OP\n#define Vc_FIXED_OP(op) \\\n template ::is_atomic>::type> \\\n Vc_INTRINSIC fixed_size_simd_mask operator op(const fixed_size_simd &a, \\\n const fixed_size_simd &b) \\\n { \\\n return {private_init, internal_data(a) op internal_data(b)}; \\\n } \\\n template ::is_atomic>::type, \\\n class = T> \\\n Vc_INTRINSIC fixed_size_simd_mask operator op(const fixed_size_simd &a, \\\n const fixed_size_simd &b) \\\n { \\\n return {internal_data0(a) op internal_data0(b), \\\n internal_data1(a) op internal_data1(b)}; \\\n }\nVc_ALL_COMPARES(Vc_FIXED_OP);\n#undef Vc_FIXED_OP\n} // namespace Detail\n\n// }}}\n// binary operators {{{1\nnamespace result_vector_type_internal\n{\ntemplate \nusing remove_cvref = typename std::remove_cv::type>::type;\n\ntemplate \nusing is_integer_larger_than_int = std::integral_constant<\n bool, std::is_integral::value &&(sizeof(T) > sizeof(int) ||\n std::is_same::value ||\n std::is_same::value)>;\n\ntemplate <\n typename L, typename R,\n std::size_t N = Traits::isSimdArray::value ? Traits::simd_vector_size::value\n : Traits::simd_vector_size::value,\n bool = (Traits::isSimdArray::value ||\n Traits::isSimdArray::value) && // one of the operands must be a SimdArray\n !(Traits::is_fixed_size_simd::value && // if both are fixed_size, use\n Traits::is_fixed_size_simd::value) && // common/operators.h\n ((std::is_arithmetic>::value && // one of the operands is a\n !is_integer_larger_than_int>::value) || // scalar type\n (std::is_arithmetic>::value &&\n !is_integer_larger_than_int>::value) ||\n // or one of the operands is Vector with Vector::size() ==\n // SimdArray::size()\n Traits::simd_vector_size::value == Traits::simd_vector_size::value)>\nstruct evaluate;\n\ntemplate struct evaluate\n{\nprivate:\n using LScalar = Traits::entry_type_of;\n using RScalar = Traits::entry_type_of;\n\n template \n using conditional = typename std::conditional::type;\n\npublic:\n // In principle we want the exact same rules for SimdArray ⨉ SimdArray as the standard\n // defines for T ⨉ U. BUT: short ⨉ short returns int (because all integral types smaller than\n // int are promoted to int before any operation). This would imply that SIMD types with integral\n // types smaller than int are more or less useless - and you could use SimdArray from the\n // start. Therefore we special-case those operations where the scalar type of both operands is\n // integral and smaller than int.\n // In addition, there is no generic support for 64-bit int SIMD types. Therefore\n // promotion to a 64-bit integral type (including `long` because it can potentially have 64\n // bits) also is not done. But if one of the operands is a scalar type that is larger than int\n // then the operator is disabled altogether. We do not want an implicit demotion.\n using type = fixed_size_simd<\n conditional<(std::is_integral::value &&std::is_integral::value &&\n sizeof(LScalar) < sizeof(int) &&\n sizeof(RScalar) < sizeof(int)),\n conditional<(sizeof(LScalar) == sizeof(RScalar)),\n conditional::value, LScalar, RScalar>,\n conditional<(sizeof(LScalar) > sizeof(RScalar)), LScalar, RScalar>>,\n decltype(std::declval() + std::declval())>,\n N>;\n};\n\n} // namespace result_vector_type_internal\n\ntemplate \nusing result_vector_type = typename result_vector_type_internal::evaluate::type;\n\n#define Vc_BINARY_OPERATORS_(op_) \\\n /*!\\brief Applies op_ component-wise and concurrently. */ \\\n template \\\n Vc_INTRINSIC result_vector_type operator op_(L &&lhs, R &&rhs) \\\n { \\\n using Return = result_vector_type; \\\n return Vc::Detail::operator op_( \\\n static_cast(std::forward(lhs)), \\\n static_cast(std::forward(rhs))); \\\n }\n/**\n * \\name Arithmetic and Bitwise Operators\n *\n * Applies the operator component-wise and concurrently on \\p lhs and \\p rhs and returns\n * a new SimdArray object containing the result values.\n *\n * This operator only participates in overload resolution if:\n * \\li At least one of the template parameters \\p L or \\p R is a SimdArray type.\n * \\li Either \\p L or \\p R is a fundamental arithmetic type but not an integral type\n * larger than \\c int \\n\n * or \\n\n * \\p L or \\p R is a Vc::Vector type with equal number of elements (Vector::size() ==\n * SimdArray::size()).\n *\n * The return type of the operator is a SimdArray type using the more precise EntryType of\n * \\p L or \\p R and the same number of elements as the SimdArray argument(s).\n */\n///@{\nVc_ALL_ARITHMETICS(Vc_BINARY_OPERATORS_);\nVc_ALL_BINARY(Vc_BINARY_OPERATORS_);\n///@}\n#undef Vc_BINARY_OPERATORS_\n#define Vc_BINARY_OPERATORS_(op_) \\\n /*!\\brief Applies op_ component-wise and concurrently. */ \\\n template \\\n Vc_INTRINSIC typename result_vector_type::mask_type operator op_(L &&lhs, \\\n R &&rhs) \\\n { \\\n using Promote = result_vector_type; \\\n return Promote(std::forward(lhs)) op_ Promote(std::forward(rhs)); \\\n }\n/**\n * \\name Compare Operators\n *\n * Applies the operator component-wise and concurrently on \\p lhs and \\p rhs and returns\n * a new SimdMaskArray object containing the result values.\n *\n * This operator only participates in overload resolution if (same rules as above):\n * \\li At least one of the template parameters \\p L or \\p R is a SimdArray type.\n * \\li Either \\p L or \\p R is a fundamental arithmetic type but not an integral type\n * larger than \\c int \\n\n * or \\n\n * \\p L or \\p R is a Vc::Vector type with equal number of elements (Vector::size() ==\n * SimdArray::size()).\n *\n * The return type of the operator is a SimdMaskArray type using the more precise EntryType of\n * \\p L or \\p R and the same number of elements as the SimdArray argument(s).\n */\n///@{\nVc_ALL_COMPARES(Vc_BINARY_OPERATORS_);\n///@}\n#undef Vc_BINARY_OPERATORS_\n\n// math functions {{{1\n#define Vc_FORWARD_UNARY_OPERATOR(name_) \\\n /*!\\brief Applies the std::name_ function component-wise and concurrently. */ \\\n template \\\n inline fixed_size_simd name_(const SimdArray &x) \\\n { \\\n return fixed_size_simd::fromOperation( \\\n Common::Operations::Forward_##name_(), x); \\\n } \\\n template \\\n fixed_size_simd name_(const fixed_size_simd &x) \\\n { \\\n return fixed_size_simd::fromOperation( \\\n Common::Operations::Forward_##name_(), x); \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\n\n#define Vc_FORWARD_UNARY_BOOL_OPERATOR(name_) \\\n /*!\\brief Applies the std::name_ function component-wise and concurrently. */ \\\n template \\\n inline fixed_size_simd_mask name_(const SimdArray &x) \\\n { \\\n return fixed_size_simd_mask::fromOperation( \\\n Common::Operations::Forward_##name_(), x); \\\n } \\\n template \\\n fixed_size_simd_mask name_(const fixed_size_simd &x) \\\n { \\\n return fixed_size_simd_mask::fromOperation( \\\n Common::Operations::Forward_##name_(), x); \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\n\n#define Vc_FORWARD_BINARY_OPERATOR(name_) \\\n /*!\\brief Applies the std::name_ function component-wise and concurrently. */ \\\n template \\\n inline fixed_size_simd name_(const SimdArray &x, \\\n const SimdArray &y) \\\n { \\\n return fixed_size_simd::fromOperation( \\\n Common::Operations::Forward_##name_(), x, y); \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\n\n/**\n * \\name Math functions\n * These functions evaluate the\n */\n///@{\nVc_FORWARD_UNARY_OPERATOR(abs);\nVc_FORWARD_UNARY_OPERATOR(asin);\nVc_FORWARD_UNARY_OPERATOR(atan);\nVc_FORWARD_BINARY_OPERATOR(atan2);\nVc_FORWARD_UNARY_OPERATOR(ceil);\nVc_FORWARD_BINARY_OPERATOR(copysign);\nVc_FORWARD_UNARY_OPERATOR(cos);\nVc_FORWARD_UNARY_OPERATOR(exp);\nVc_FORWARD_UNARY_OPERATOR(exponent);\nVc_FORWARD_UNARY_OPERATOR(floor);\n/// Applies the std::fma function component-wise and concurrently.\ntemplate \ninline SimdArray fma(const SimdArray &a, const SimdArray &b,\n const SimdArray &c)\n{\n return SimdArray::fromOperation(Common::Operations::Forward_fma(), a, b, c);\n}\nVc_FORWARD_UNARY_BOOL_OPERATOR(isfinite);\nVc_FORWARD_UNARY_BOOL_OPERATOR(isinf);\nVc_FORWARD_UNARY_BOOL_OPERATOR(isnan);\nVc_FORWARD_UNARY_BOOL_OPERATOR(isnegative);\n/// Applies the std::frexp function component-wise and concurrently.\ntemplate \ninline SimdArray frexp(const SimdArray &x, SimdArray *e)\n{\n return SimdArray::fromOperation(Common::Operations::Forward_frexp(), x, e);\n}\n/// Applies the std::ldexp function component-wise and concurrently.\ntemplate \ninline SimdArray ldexp(const SimdArray &x, const SimdArray &e)\n{\n return SimdArray::fromOperation(Common::Operations::Forward_ldexp(), x, e);\n}\nVc_FORWARD_UNARY_OPERATOR(log);\nVc_FORWARD_UNARY_OPERATOR(log10);\nVc_FORWARD_UNARY_OPERATOR(log2);\nVc_FORWARD_UNARY_OPERATOR(reciprocal);\nVc_FORWARD_UNARY_OPERATOR(round);\nVc_FORWARD_UNARY_OPERATOR(rsqrt);\nVc_FORWARD_UNARY_OPERATOR(sin);\n/// Determines sine and cosine concurrently and component-wise on \\p x.\ntemplate \nvoid sincos(const SimdArray &x, SimdArray *sin, SimdArray *cos)\n{\n SimdArray::callOperation(Common::Operations::Forward_sincos(), x, sin, cos);\n}\nVc_FORWARD_UNARY_OPERATOR(sqrt);\nVc_FORWARD_UNARY_OPERATOR(trunc);\nVc_FORWARD_BINARY_OPERATOR(min);\nVc_FORWARD_BINARY_OPERATOR(max);\n///@}\n#undef Vc_FORWARD_UNARY_OPERATOR\n#undef Vc_FORWARD_UNARY_BOOL_OPERATOR\n#undef Vc_FORWARD_BINARY_OPERATOR\n\n// simd_cast {{{1\n#ifdef Vc_MSVC\n#define Vc_DUMMY_ARG0 , int = 0\n#define Vc_DUMMY_ARG1 , long = 0\n#define Vc_DUMMY_ARG2 , short = 0\n#define Vc_DUMMY_ARG3 , char = '0'\n#define Vc_DUMMY_ARG4 , unsigned = 0u\n#define Vc_DUMMY_ARG5 , unsigned short = 0u\n#else\n#define Vc_DUMMY_ARG0\n#define Vc_DUMMY_ARG1\n#define Vc_DUMMY_ARG2\n#define Vc_DUMMY_ARG3\n#define Vc_DUMMY_ARG4\n#define Vc_DUMMY_ARG5\n#endif // Vc_MSVC\n\n// simd_cast_impl_smaller_input {{{2\n// The following function can be implemented without the sizeof...(From) overload.\n// However, ICC has a bug (Premier Issue #6000116338) which leads to an ICE. Splitting the\n// function in two works around the issue.\ntemplate \nVc_INTRINSIC Vc_CONST enable_if\nsimd_cast_impl_smaller_input(const From &... xs, const T &last)\n{\n Return r = simd_cast(xs...);\n for (size_t i = 0; i < N; ++i) {\n r[i + N * sizeof...(From)] = static_cast(last[i]);\n }\n return r;\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return simd_cast_impl_smaller_input(const T &last)\n{\n Return r = Return();\n for (size_t i = 0; i < N; ++i) {\n r[i] = static_cast(last[i]);\n }\n return r;\n}\ntemplate \nVc_INTRINSIC Vc_CONST enable_if simd_cast_impl_larger_input(\n const From &... xs, const T &last)\n{\n Return r = simd_cast(xs...);\n for (size_t i = N * sizeof...(From); i < Return::Size; ++i) {\n r[i] = static_cast(last[i - N * sizeof...(From)]);\n }\n return r;\n}\ntemplate \nVc_INTRINSIC Vc_CONST Return simd_cast_impl_larger_input(const T &last)\n{\n Return r = Return();\n for (size_t i = 0; i < Return::size(); ++i) {\n r[i] = static_cast(last[i]);\n }\n return r;\n}\n\n// simd_cast_without_last (declaration) {{{2\ntemplate \nVc_INTRINSIC_L Vc_CONST_L Return\n simd_cast_without_last(const From &... xs, const T &) Vc_INTRINSIC_R Vc_CONST_R;\n\n// are_all_types_equal {{{2\ntemplate struct are_all_types_equal;\ntemplate \nstruct are_all_types_equal : public std::integral_constant\n{\n};\ntemplate \nstruct are_all_types_equal\n : public std::integral_constant<\n bool, std::is_same::value && are_all_types_equal::value>\n{\n};\n\n// simd_cast_interleaved_argument_order (declarations) {{{2\n/*! \\internal\n The need for simd_cast_interleaved_argument_order stems from a shortcoming in pack\n expansion of variadic templates in C++. For a simd_cast with SimdArray arguments that\n are bisectable (i.e. \\c storage_type0 and \\c storage_type1 are equal) the generic\n implementation needs to forward to a simd_cast of the \\c internal_data0 and \\c\n internal_data1 of the arguments. But the required order of arguments is\n `internal_data0(arg0), internal_data1(arg0), internal_data0(arg1), ...`. This is\n impossible to achieve with pack expansion. It is only possible to write\n `internal_data0(args)..., internal_data1(args)...` and thus have the argument order\n mixed up. The simd_cast_interleaved_argument_order “simply” calls simd_cast with the\n arguments correctly reordered (i.e. interleaved).\n\n The implementation of simd_cast_interleaved_argument_order is done generically, so that\n it supports any number of arguments. The central idea of the implementation is an\n `extract` function which returns one value of an argument pack determined via an index\n passed as template argument. This index is generated via an index_sequence. The\n `extract` function uses two argument packs (of equal size) to easily return values from\n the front and middle of the argument pack (for doing the deinterleave).\n */\ntemplate \nVc_INTRINSIC Vc_CONST Return\n simd_cast_interleaved_argument_order(const Ts &... a, const Ts &... b);\n\n// simd_cast_with_offset (declarations and one impl) {{{2\n// offset == 0 {{{3\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(are_all_types_equal::value && offset == 0), Return>\n simd_cast_with_offset(const From &x, const Froms &... xs);\n// offset > 0 && offset divisible by Return::Size {{{3\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(From::Size > offset && offset > 0 && offset % Return::Size == 0), Return>\n simd_cast_with_offset(const From &x);\n// offset > 0 && offset NOT divisible && Return is non-atomic simd(mask)array {{{3\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(From::Size > offset && offset > 0 && offset % Return::Size != 0 &&\n ((Traits::isSimdArray::value &&\n !Traits::isAtomicSimdArray::value) ||\n (Traits::isSimdMaskArray::value &&\n !Traits::isAtomicSimdMaskArray::value))),\n Return>\n simd_cast_with_offset(const From &x);\n// offset > 0 && offset NOT divisible && Return is atomic simd(mask)array {{{3\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(From::Size > offset && offset > 0 && offset % Return::Size != 0 &&\n ((Traits::isSimdArray::value &&\n Traits::isAtomicSimdArray::value) ||\n (Traits::isSimdMaskArray::value &&\n Traits::isAtomicSimdMaskArray::value))),\n Return>\n simd_cast_with_offset(const From &x);\n// offset > first argument (drops first arg) {{{3\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<\n (are_all_types_equal::value && From::Size <= offset), Return>\n simd_cast_with_offset(const From &, const Froms &... xs)\n{\n return simd_cast_with_offset(xs...);\n}\n\n// offset > first and only argument (returns Zero) {{{3\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(From::Size <= offset), Return> simd_cast_with_offset(\n const From &)\n{\n return Return(0);\n}\n\n// first_type_of {{{2\ntemplate struct first_type_of_impl\n{\n using type = T;\n};\ntemplate using first_type_of = typename first_type_of_impl::type;\n\n// simd_cast_drop_arguments (declarations) {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return simd_cast_drop_arguments(From x);\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(are_all_types_equal::value &&\n sizeof...(Froms) * first_type_of::Size < Return::Size),\n Return>\n simd_cast_drop_arguments(Froms... xs, first_type_of x);\n// The following function can be implemented without the sizeof...(From) overload.\n// However, ICC has a bug (Premier Issue #6000116338) which leads to an ICE. Splitting the\n// function in two works around the issue.\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<\n (are_all_types_equal::value &&\n (1 + sizeof...(Froms)) * From::Size >= Return::Size && sizeof...(Froms) != 0),\n Return>\nsimd_cast_drop_arguments(Froms... xs, From x, From);\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(are_all_types_equal::value && From::Size >= Return::Size), Return>\n simd_cast_drop_arguments(From x, From);\n\nnamespace\n{\n#ifdef Vc_DEBUG_SIMD_CAST\nvoid debugDoNothing(const std::initializer_list &) {}\ntemplate \ninline void vc_debug_(const char *prefix, const char *suffix, const T0 &arg0,\n const Ts &... args)\n{\n std::cerr << prefix << arg0;\n debugDoNothing({&(std::cerr << \", \" << args)...});\n std::cerr << suffix;\n}\n#else\ntemplate \nVc_INTRINSIC void vc_debug_(const char *, const char *, const T0 &, const Ts &...)\n{\n}\n#endif\n} // unnamed namespace\n\n// is_less trait{{{2\ntemplate \nstruct is_less : public std::integral_constant {\n};\n\n// is_power_of_2 trait{{{2\ntemplate \nstruct is_power_of_2 : public std::integral_constant {\n};\n\n// simd_cast(xs...) to SimdArray/-mask {{{2\n#define Vc_SIMDARRAY_CASTS(SimdArrayType_, NativeType_) \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if< \\\n (Traits::isAtomic##SimdArrayType_::value && \\\n is_less::Size * sizeof...(Froms), Return::Size>::value && \\\n are_all_types_equal, Froms...>::value && \\\n !detail::is_fixed_size_abi::value), \\\n Return> \\\n simd_cast(NativeType_ x, Froms... xs) \\\n { \\\n vc_debug_(\"simd_cast{1}(\", \")\\n\", x, xs...); \\\n return {private_init, simd_cast(x, xs...)}; \\\n } \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if< \\\n (Traits::isAtomic##SimdArrayType_::value && \\\n !is_less::Size * sizeof...(Froms), Return::Size>::value && \\\n are_all_types_equal, Froms...>::value && \\\n !detail::is_fixed_size_abi::value), \\\n Return> \\\n simd_cast(NativeType_ x, Froms... xs) \\\n { \\\n vc_debug_(\"simd_cast{2}(\", \")\\n\", x, xs...); \\\n return {simd_cast_without_last, Froms...>(x, xs...)}; \\\n } \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(Traits::is##SimdArrayType_::value && \\\n !Traits::isAtomic##SimdArrayType_::value && \\\n is_less(), \\\n NativeType_::Size *(1 + sizeof...(Froms))>::value && \\\n are_all_types_equal, Froms...>::value && \\\n !detail::is_fixed_size_abi::value), \\\n Return> \\\n simd_cast(NativeType_ x, Froms... xs) \\\n { \\\n vc_debug_(\"simd_cast{3}(\", \")\\n\", x, xs...); \\\n using R0 = typename Return::storage_type0; \\\n using R1 = typename Return::storage_type1; \\\n return {simd_cast_drop_arguments(x, xs...), \\\n simd_cast_with_offset(x, xs...)}; \\\n } \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(Traits::is##SimdArrayType_::value && \\\n !Traits::isAtomic##SimdArrayType_::value && \\\n !is_less(), \\\n NativeType_::Size *(1 + sizeof...(Froms))>::value && \\\n are_all_types_equal, Froms...>::value && \\\n !detail::is_fixed_size_abi::value), \\\n Return> \\\n simd_cast(NativeType_ x, Froms... xs) \\\n { \\\n vc_debug_(\"simd_cast{4}(\", \")\\n\", x, xs...); \\\n using R0 = typename Return::storage_type0; \\\n using R1 = typename Return::storage_type1; \\\n return {simd_cast(x, xs...), R1(0)}; \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\n\nVc_SIMDARRAY_CASTS(SimdArray, Vc::Vector);\nVc_SIMDARRAY_CASTS(SimdMaskArray, Vc::Mask);\n#undef Vc_SIMDARRAY_CASTS\n\n// simd_cast(V) {{{2\n#define Vc_SIMDARRAY_CASTS(SimdArrayType_, NativeType_) \\\n /* SIMD Vector/Mask to atomic SimdArray/simdmaskarray */ \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if::value, Return> \\\n simd_cast(NativeType_ x Vc_DUMMY_ARG0) \\\n { \\\n vc_debug_(\"simd_cast{offset, atomic}(\", \")\\n\", offset, x); \\\n return {private_init, simd_cast(x)}; \\\n } \\\n /* both halves of Return array are extracted from argument */ \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(Traits::is##SimdArrayType_::value && \\\n !Traits::isAtomic##SimdArrayType_::value && \\\n Return::Size * offset + Common::left_size() < \\\n NativeType_::Size), \\\n Return> \\\n simd_cast(NativeType_ x Vc_DUMMY_ARG1) \\\n { \\\n vc_debug_(\"simd_cast{offset, split Return}(\", \")\\n\", offset, x); \\\n using R0 = typename Return::storage_type0; \\\n constexpr int entries_offset = offset * Return::Size; \\\n constexpr int entries_offset_right = entries_offset + R0::Size; \\\n return { \\\n simd_cast_with_offset(x), \\\n simd_cast_with_offset( \\\n x)}; \\\n } \\\n /* SIMD Vector/Mask to non-atomic SimdArray/simdmaskarray */ \\\n /* right half of Return array is zero */ \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(Traits::is##SimdArrayType_::value && \\\n !Traits::isAtomic##SimdArrayType_::value && \\\n Return::Size * offset + Common::left_size() >= \\\n NativeType_::Size), \\\n Return> \\\n simd_cast(NativeType_ x Vc_DUMMY_ARG2) \\\n { \\\n vc_debug_(\"simd_cast{offset, R1::Zero}(\", \")\\n\", offset, x); \\\n using R0 = typename Return::storage_type0; \\\n using R1 = typename Return::storage_type1; \\\n constexpr int entries_offset = offset * Return::Size; \\\n return {simd_cast_with_offset(x), R1(0)}; \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\n\nVc_SIMDARRAY_CASTS(SimdArray, Vc::Vector);\nVc_SIMDARRAY_CASTS(SimdMaskArray, Vc::Mask);\n#undef Vc_SIMDARRAY_CASTS\n\n// simd_cast(xs...) from SimdArray/-mask {{{2\n#define Vc_SIMDARRAY_CASTS(SimdArrayType_) \\\n /* indivisible SimdArrayType_ */ \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(are_all_types_equal, From...>::value && \\\n (sizeof...(From) == 0 || N * sizeof...(From) < Return::Size) && \\\n !std::is_same>::value), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x0, const From &... xs) \\\n { \\\n vc_debug_(\"simd_cast{indivisible}(\", \")\\n\", x0, xs...); \\\n return simd_cast(internal_data(x0), internal_data(xs)...); \\\n } \\\n /* indivisible SimdArrayType_ && can drop arguments from the end */ \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(are_all_types_equal, From...>::value && \\\n (sizeof...(From) > 0 && (N * sizeof...(From) >= Return::Size)) && \\\n !std::is_same>::value), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x0, const From &... xs) \\\n { \\\n vc_debug_(\"simd_cast{indivisible2}(\", \")\\n\", x0, xs...); \\\n return simd_cast_without_last::storage_type, \\\n typename From::storage_type...>( \\\n internal_data(x0), internal_data(xs)...); \\\n } \\\n /* bisectable SimdArrayType_ (N = 2^n) && never too large */ \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if< \\\n (N != M && are_all_types_equal, From...>::value && \\\n !std::is_same>::value && \\\n is_less::value && is_power_of_2::value), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x0, const From &... xs) \\\n { \\\n vc_debug_(\"simd_cast{bisectable}(\", \")\\n\", x0, xs...); \\\n return simd_cast_interleaved_argument_order< \\\n Return, typename SimdArrayType_::storage_type0, \\\n typename From::storage_type0...>(internal_data0(x0), internal_data0(xs)..., \\\n internal_data1(x0), internal_data1(xs)...); \\\n } \\\n /* bisectable SimdArrayType_ (N = 2^n) && input so large that at least the last \\\n * input can be dropped */ \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if< \\\n (N != M && are_all_types_equal, From...>::value && \\\n !is_less::value && is_power_of_2::value), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x0, const From &... xs) \\\n { \\\n vc_debug_(\"simd_cast{bisectable2}(\", \")\\n\", x0, xs...); \\\n return simd_cast_without_last, From...>( \\\n x0, xs...); \\\n } \\\n /* remaining SimdArrayType_ input never larger (N != 2^n) */ \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if< \\\n (N != M && are_all_types_equal, From...>::value && \\\n N * (1 + sizeof...(From)) <= Return::Size && !is_power_of_2::value), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x0, const From &... xs) \\\n { \\\n vc_debug_(\"simd_cast{remaining}(\", \")\\n\", x0, xs...); \\\n return simd_cast_impl_smaller_input, \\\n From...>(x0, xs...); \\\n } \\\n /* remaining SimdArrayType_ input larger (N != 2^n) */ \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if< \\\n (N != M && are_all_types_equal, From...>::value && \\\n N * (1 + sizeof...(From)) > Return::Size && !is_power_of_2::value), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x0, const From &... xs) \\\n { \\\n vc_debug_(\"simd_cast{remaining2}(\", \")\\n\", x0, xs...); \\\n return simd_cast_impl_larger_input, \\\n From...>(x0, xs...); \\\n } \\\n /* a single bisectable SimdArrayType_ (N = 2^n) too large */ \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(N != M && N >= 2 * Return::Size && is_power_of_2::value), Return> \\\n simd_cast(const SimdArrayType_ &x) \\\n { \\\n vc_debug_(\"simd_cast{single bisectable}(\", \")\\n\", x); \\\n return simd_cast(internal_data0(x)); \\\n } \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if<(N != M && N > Return::Size && \\\n N < 2 * Return::Size && is_power_of_2::value), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x) \\\n { \\\n vc_debug_(\"simd_cast{single bisectable2}(\", \")\\n\", x); \\\n return simd_cast(internal_data0(x), internal_data1(x)); \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\n\nVc_SIMDARRAY_CASTS(SimdArray);\nVc_SIMDARRAY_CASTS(SimdMaskArray);\n#undef Vc_SIMDARRAY_CASTS\ntemplate >::value>>\nVc_INTRINSIC Return simd_cast(const fixed_size_simd &x, const Ts &... xs)\n{\n return simd_cast(static_cast &>(x),\n static_cast &>(xs)...);\n}\ntemplate >::value>>\nVc_INTRINSIC Return simd_cast(const fixed_size_simd_mask &x, const Ts &... xs)\n{\n return simd_cast(static_cast &>(x),\n static_cast &>(xs)...);\n}\n\n// simd_cast(SimdArray/-mask) {{{2\n#define Vc_SIMDARRAY_CASTS(SimdArrayType_) \\\n /* offset == 0 is like without offset */ \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if<(offset == 0), Return> simd_cast( \\\n const SimdArrayType_ &x Vc_DUMMY_ARG0) \\\n { \\\n vc_debug_(\"simd_cast{offset == 0}(\", \")\\n\", offset, x); \\\n return simd_cast(x); \\\n } \\\n /* forward to V */ \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if<(offset != 0), Return> simd_cast( \\\n const SimdArrayType_ &x Vc_DUMMY_ARG1) \\\n { \\\n vc_debug_(\"simd_cast{offset, forward}(\", \")\\n\", offset, x); \\\n return simd_cast(internal_data(x)); \\\n } \\\n /* convert from right member of SimdArray */ \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(N != M && offset * Return::Size >= Common::left_size() && \\\n offset != 0 && Common::left_size() % Return::Size == 0), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x Vc_DUMMY_ARG2) \\\n { \\\n vc_debug_(\"simd_cast{offset, right}(\", \")\\n\", offset, x); \\\n return simd_cast() / Return::Size>( \\\n internal_data1(x)); \\\n } \\\n /* same as above except for odd cases where offset * Return::Size doesn't fit the \\\n * left side of the SimdArray */ \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(N != M && offset * Return::Size >= Common::left_size() && \\\n offset != 0 && Common::left_size() % Return::Size != 0), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x Vc_DUMMY_ARG3) \\\n { \\\n vc_debug_(\"simd_cast{offset, right, nofit}(\", \")\\n\", offset, x); \\\n return simd_cast_with_offset()>( \\\n internal_data1(x)); \\\n } \\\n /* convert from left member of SimdArray */ \\\n template \\\n Vc_INTRINSIC Vc_CONST enable_if< \\\n (N != M && /*offset * Return::Size < Common::left_size() &&*/ \\\n offset != 0 && (offset + 1) * Return::Size <= Common::left_size()), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x Vc_DUMMY_ARG4) \\\n { \\\n vc_debug_(\"simd_cast{offset, left}(\", \")\\n\", offset, x); \\\n return simd_cast(internal_data0(x)); \\\n } \\\n /* fallback to copying scalars */ \\\n template \\\n Vc_INTRINSIC Vc_CONST \\\n enable_if<(N != M && (offset * Return::Size < Common::left_size()) && \\\n offset != 0 && (offset + 1) * Return::Size > Common::left_size()), \\\n Return> \\\n simd_cast(const SimdArrayType_ &x Vc_DUMMY_ARG5) \\\n { \\\n vc_debug_(\"simd_cast{offset, copy scalars}(\", \")\\n\", offset, x); \\\n using R = typename Return::EntryType; \\\n Return r = Return(0); \\\n for (std::size_t i = offset * Return::Size; \\\n i < std::min(N, (offset + 1) * Return::Size); ++i) { \\\n r[i - offset * Return::Size] = static_cast(x[i]); \\\n } \\\n return r; \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\nVc_SIMDARRAY_CASTS(SimdArray);\nVc_SIMDARRAY_CASTS(SimdMaskArray);\n#undef Vc_SIMDARRAY_CASTS\n// simd_cast_drop_arguments (definitions) {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return simd_cast_drop_arguments(From x)\n{\n return simd_cast(x);\n}\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(are_all_types_equal::value &&\n sizeof...(Froms) * first_type_of::Size < Return::Size),\n Return>\n simd_cast_drop_arguments(Froms... xs, first_type_of x)\n{\n return simd_cast(xs..., x);\n}\n// The following function can be implemented without the sizeof...(From) overload.\n// However, ICC has a bug (Premier Issue #6000116338) which leads to an ICE. Splitting the\n// function in two works around the issue.\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<\n (are_all_types_equal::value &&\n (1 + sizeof...(Froms)) * From::Size >= Return::Size && sizeof...(Froms) != 0),\n Return>\nsimd_cast_drop_arguments(Froms... xs, From x, From)\n{\n return simd_cast_drop_arguments(xs..., x);\n}\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(are_all_types_equal::value && From::Size >= Return::Size), Return>\n simd_cast_drop_arguments(From x, From)\n{\n return simd_cast_drop_arguments(x);\n}\n\n// simd_cast_with_offset (definitions) {{{2\n template \n Vc_INTRINSIC Vc_CONST\n enable_if<(From::Size > offset && offset > 0 && offset % Return::Size == 0),\n Return> simd_cast_with_offset(const From &x)\n{\n return simd_cast(x);\n}\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(From::Size > offset && offset > 0 && offset % Return::Size != 0 &&\n ((Traits::isSimdArray::value &&\n !Traits::isAtomicSimdArray::value) ||\n (Traits::isSimdMaskArray::value &&\n !Traits::isAtomicSimdMaskArray::value))),\n Return>\n simd_cast_with_offset(const From &x)\n{\n using R0 = typename Return::storage_type0;\n using R1 = typename Return::storage_type1;\n return {simd_cast_with_offset(x),\n simd_cast_with_offset(x)};\n}\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(From::Size > offset && offset > 0 && offset % Return::Size != 0 &&\n ((Traits::isSimdArray::value &&\n Traits::isAtomicSimdArray::value) ||\n (Traits::isSimdMaskArray::value &&\n Traits::isAtomicSimdMaskArray::value))),\n Return>\n simd_cast_with_offset(const From &x)\n{\n return simd_cast(x.shifted(offset % Return::Size));\n}\ntemplate \nVc_INTRINSIC Vc_CONST\n enable_if<(are_all_types_equal::value && offset == 0), Return>\n simd_cast_with_offset(const From &x, const Froms &... xs)\n{\n return simd_cast(x, xs...);\n}\n\n// simd_cast_without_last (definition) {{{2\ntemplate \nVc_INTRINSIC Vc_CONST Return simd_cast_without_last(const From &... xs, const T &)\n{\n return simd_cast(xs...);\n}\n\n// simd_cast_interleaved_argument_order (definitions) {{{2\n\n#ifdef Vc_MSVC\n// MSVC doesn't see that the Ts pack below can be empty and thus complains when extract_interleaved\n// is called with only 2 arguments. These overloads here are *INCORRECT standard C++*, but they make\n// MSVC do the right thing.\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(I == 0), T0> extract_interleaved(const T0 &a0, const T0 &)\n{\n return a0;\n}\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(I == 1), T0> extract_interleaved(const T0 &, const T0 &b0)\n{\n return b0;\n}\n#endif // Vc_MSVC\n\n/// \\internal returns the first argument\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(I == 0), T0> extract_interleaved(const T0 &a0,\n const Ts &...,\n const T0 &,\n const Ts &...)\n{\n return a0;\n}\n/// \\internal returns the center argument\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(I == 1), T0> extract_interleaved(const T0 &,\n const Ts &...,\n const T0 &b0,\n const Ts &...)\n{\n return b0;\n}\n/// \\internal drops the first and center arguments and recurses\ntemplate \nVc_INTRINSIC Vc_CONST enable_if<(I > 1), T0> extract_interleaved(const T0 &,\n const Ts &... a,\n const T0 &,\n const Ts &... b)\n{\n return extract_interleaved(a..., b...);\n}\n/// \\internal calls simd_cast with correct argument order thanks to extract_interleaved\ntemplate \nVc_INTRINSIC Vc_CONST Return\n simd_cast_interleaved_argument_order_1(index_sequence, const Ts &... a,\n const Ts &... b)\n{\n return simd_cast(extract_interleaved(a..., b...)...);\n}\n/// \\internal constructs the necessary index_sequence to pass it to\n/// simd_cast_interleaved_argument_order_1\ntemplate \nVc_INTRINSIC Vc_CONST Return\n simd_cast_interleaved_argument_order(const Ts &... a, const Ts &... b)\n{\n using seq = make_index_sequence;\n return simd_cast_interleaved_argument_order_1(seq(), a..., b...);\n}\n\n// conditional_assign {{{1\n#define Vc_CONDITIONAL_ASSIGN(name_, op_) \\\n template \\\n Vc_INTRINSIC enable_if conditional_assign( \\\n SimdArray &lhs, M &&mask, U &&rhs) \\\n { \\\n lhs(mask) op_ rhs; \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\nVc_CONDITIONAL_ASSIGN( Assign, =);\nVc_CONDITIONAL_ASSIGN( PlusAssign, +=);\nVc_CONDITIONAL_ASSIGN( MinusAssign, -=);\nVc_CONDITIONAL_ASSIGN( MultiplyAssign, *=);\nVc_CONDITIONAL_ASSIGN( DivideAssign, /=);\nVc_CONDITIONAL_ASSIGN( RemainderAssign, %=);\nVc_CONDITIONAL_ASSIGN( XorAssign, ^=);\nVc_CONDITIONAL_ASSIGN( AndAssign, &=);\nVc_CONDITIONAL_ASSIGN( OrAssign, |=);\nVc_CONDITIONAL_ASSIGN( LeftShiftAssign,<<=);\nVc_CONDITIONAL_ASSIGN(RightShiftAssign,>>=);\n#undef Vc_CONDITIONAL_ASSIGN\n\n#define Vc_CONDITIONAL_ASSIGN(name_, expr_) \\\n template \\\n Vc_INTRINSIC enable_if> \\\n conditional_assign(SimdArray &lhs, M &&mask) \\\n { \\\n return expr_; \\\n } \\\n Vc_NOTHING_EXPECTING_SEMICOLON\nVc_CONDITIONAL_ASSIGN(PostIncrement, lhs(mask)++);\nVc_CONDITIONAL_ASSIGN( PreIncrement, ++lhs(mask));\nVc_CONDITIONAL_ASSIGN(PostDecrement, lhs(mask)--);\nVc_CONDITIONAL_ASSIGN( PreDecrement, --lhs(mask));\n#undef Vc_CONDITIONAL_ASSIGN\n// transpose_impl {{{1\nnamespace Common\n{\ntemplate \ninline void transpose_impl(\n TransposeTag<4, 4>, SimdArray *Vc_RESTRICT r[],\n const TransposeProxy, SimdArray,\n SimdArray, SimdArray> &proxy)\n{\n V *Vc_RESTRICT r2[4] = {&internal_data(*r[0]), &internal_data(*r[1]),\n &internal_data(*r[2]), &internal_data(*r[3])};\n transpose_impl(TransposeTag<4, 4>(), &r2[0],\n TransposeProxy{internal_data(std::get<0>(proxy.in)),\n internal_data(std::get<1>(proxy.in)),\n internal_data(std::get<2>(proxy.in)),\n internal_data(std::get<3>(proxy.in))});\n}\n\ntemplate \ninline void transpose_impl(\n TransposeTag<2, 4>, SimdArray *Vc_RESTRICT r[],\n const TransposeProxy, SimdArray,\n SimdArray, SimdArray> &proxy)\n{\n auto &lo = *r[0];\n auto &hi = *r[1];\n internal_data0(internal_data0(lo)) = internal_data0(std::get<0>(proxy.in));\n internal_data1(internal_data0(lo)) = internal_data0(std::get<1>(proxy.in));\n internal_data0(internal_data1(lo)) = internal_data0(std::get<2>(proxy.in));\n internal_data1(internal_data1(lo)) = internal_data0(std::get<3>(proxy.in));\n internal_data0(internal_data0(hi)) = internal_data1(std::get<0>(proxy.in));\n internal_data1(internal_data0(hi)) = internal_data1(std::get<1>(proxy.in));\n internal_data0(internal_data1(hi)) = internal_data1(std::get<2>(proxy.in));\n internal_data1(internal_data1(hi)) = internal_data1(std::get<3>(proxy.in));\n}\n\ntemplate \ninline void transpose_impl(\n TransposeTag<4, 4>, SimdArray *Vc_RESTRICT r[],\n const TransposeProxy, SimdArray,\n SimdArray, SimdArray> &proxy)\n{\n V *Vc_RESTRICT r2[4] = {&internal_data(*r[0]), &internal_data(*r[1]),\n &internal_data(*r[2]), &internal_data(*r[3])};\n transpose_impl(TransposeTag<4, 4>(), &r2[0],\n TransposeProxy{internal_data(std::get<0>(proxy.in)),\n internal_data(std::get<1>(proxy.in)),\n internal_data(std::get<2>(proxy.in)),\n internal_data(std::get<3>(proxy.in))});\n}\n\ntemplate \ninline void transpose_impl(\n TransposeTag<4, 4>, SimdArray *Vc_RESTRICT r[],\n const TransposeProxy, SimdArray,\n SimdArray, SimdArray> &proxy)\n{\n SimdArray *Vc_RESTRICT r0[4 / 2] = {r[0], r[1]};\n SimdArray *Vc_RESTRICT r1[4 / 2] = {r[2], r[3]};\n using H = SimdArray;\n transpose_impl(TransposeTag<2, 4>(), &r0[0],\n TransposeProxy{internal_data0(std::get<0>(proxy.in)),\n internal_data0(std::get<1>(proxy.in)),\n internal_data0(std::get<2>(proxy.in)),\n internal_data0(std::get<3>(proxy.in))});\n transpose_impl(TransposeTag<2, 4>(), &r1[0],\n TransposeProxy{internal_data1(std::get<0>(proxy.in)),\n internal_data1(std::get<1>(proxy.in)),\n internal_data1(std::get<2>(proxy.in)),\n internal_data1(std::get<3>(proxy.in))});\n}\n\n/* TODO:\ntemplate \ninline enable_if<(N > VSize), void> transpose_impl(\n std::array * Vc_RESTRICT, 4> & r,\n const TransposeProxy, SimdArray,\n SimdArray, SimdArray> &proxy)\n{\n typedef SimdArray SA;\n std::array r0 = {\n {&internal_data0(*r[0]), &internal_data0(*r[1]), &internal_data0(*r[2]),\n &internal_data0(*r[3])}};\n transpose_impl(\n r0, TransposeProxy{\n internal_data0(std::get<0>(proxy.in)),\n internal_data0(std::get<1>(proxy.in)),\n internal_data0(std::get<2>(proxy.in)),\n internal_data0(std::get<3>(proxy.in))});\n\n std::array r1 = {\n {&internal_data1(*r[0]), &internal_data1(*r[1]), &internal_data1(*r[2]),\n &internal_data1(*r[3])}};\n transpose_impl(\n r1, TransposeProxy{\n internal_data1(std::get<0>(proxy.in)),\n internal_data1(std::get<1>(proxy.in)),\n internal_data1(std::get<2>(proxy.in)),\n internal_data1(std::get<3>(proxy.in))});\n}\n*/\n} // namespace Common\n\n// }}}1\nnamespace Detail\n{\n// InterleaveImpl for SimdArrays {{{\n// atomic {{{1\ntemplate \nstruct InterleaveImpl, N, VSizeof> {\n template \n static Vc_INTRINSIC void interleave(T *const data, const I &i, const VV &... vv)\n {\n InterleaveImpl::interleave(data, i, internal_data(vv)...);\n }\n template \n static Vc_INTRINSIC void deinterleave(T const *const data, const I &i, VV &... vv)\n {\n InterleaveImpl::deinterleave(data, i, internal_data(vv)...);\n }\n};\n\n// generic (TODO) {{{1\n/*\ntemplate \nstruct InterleaveImpl, N, VSizeof> {\n using SA = SimdArray;\n using SA0 = typename SA::storage_type0;\n using SA1 = typename SA::storage_type1;\n\n template \n static Vc_INTRINSIC void interleave(T *const data, const I &i, const VV &... vv)\n {\n InterleaveImpl::interleave(\n data, i, // i needs to be split\n internal_data0(vv)...);\n InterleaveImpl::interleave(\n data, // how far to advance data?\n i, // i needs to be split\n internal_data1(vv)...);\n }\n template \n static Vc_INTRINSIC void deinterleave(T const *const data, const I &i, VV &... vv)\n {\n InterleaveImpl::deinterleave(data, i, internal_data(vv)...);\n }\n};\n*/\n} // namespace Detail\n// }}}\n/// @}\n\n} // namespace Vc_VERSIONED_NAMESPACE\n\n// numeric_limits {{{1\nnamespace std\n{\ntemplate \nstruct numeric_limits> : public numeric_limits {\nprivate:\n using R = Vc::SimdArray;\n\npublic:\n static Vc_ALWAYS_INLINE Vc_CONST R max() noexcept { return numeric_limits::max(); }\n static Vc_ALWAYS_INLINE Vc_CONST R min() noexcept { return numeric_limits::min(); }\n static Vc_ALWAYS_INLINE Vc_CONST R lowest() noexcept\n {\n return numeric_limits::lowest();\n }\n static Vc_ALWAYS_INLINE Vc_CONST R epsilon() noexcept\n {\n return numeric_limits::epsilon();\n }\n static Vc_ALWAYS_INLINE Vc_CONST R round_error() noexcept\n {\n return numeric_limits::round_error();\n }\n static Vc_ALWAYS_INLINE Vc_CONST R infinity() noexcept\n {\n return numeric_limits::infinity();\n }\n static Vc_ALWAYS_INLINE Vc_CONST R quiet_NaN() noexcept\n {\n return numeric_limits::quiet_NaN();\n }\n static Vc_ALWAYS_INLINE Vc_CONST R signaling_NaN() noexcept\n {\n return numeric_limits::signaling_NaN();\n }\n static Vc_ALWAYS_INLINE Vc_CONST R denorm_min() noexcept\n {\n return numeric_limits::denorm_min();\n }\n};\n} // namespace std\n//}}}1\n\n#endif // VC_COMMON_SIMDARRAY_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/simdarrayfwd.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_SIMDARRAYFWD_H_\n#define VC_COMMON_SIMDARRAYFWD_H_\n\n#include \"../scalar/types.h\"\n#include \"../sse/types.h\"\n#include \"../avx/types.h\"\n\n#include \"utility.h\"\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n// specialization of Vector for fixed_size {{{\ntemplate \nclass Vector> : public SimdArray\n{\n using SimdArray::SimdArray;\n\npublic:\n // overload copy to force argument passing via the stack. This makes the type more\n // usable on ABI boundaries\n Vc_INTRINSIC Vector(const Vector &x) : SimdArray(x) {}\n Vc_INTRINSIC Vector &operator=(const Vector &x)\n {\n SimdArray::operator=(x);\n return *this;\n }\n Vector() = default;\n\n using abi_type = simd_abi::fixed_size;\n using abi = abi_type;\n\n Vc_DEPRECATED(\"use Vector([](int n) { return n; }) instead of \"\n \"Vector::IndexesFromZero()\") static Vector IndexesFromZero()\n {\n return Vector([](size_t i) -> T { return i; });\n }\n Vc_DEPRECATED(\"use 0 instead of Vector::Zero()\") static Vector Zero() { return 0; }\n Vc_DEPRECATED(\"use 1 instead of Vector::One()\") static Vector One() { return 1; }\n};\n\ntemplate \nclass Mask> : public SimdMaskArray\n{\n using SimdMaskArray::SimdMaskArray;\n\npublic:\n // overload copy to force argument passing via the stack. This makes the type more\n // usable on ABI boundaries\n Vc_INTRINSIC Mask(const Mask &x) : SimdMaskArray(x) {}\n Vc_INTRINSIC Mask &operator=(const Mask &x)\n {\n SimdMaskArray::operator=(x);\n return *this;\n }\n Mask() = default;\n\n using abi_type = simd_abi::fixed_size;\n using abi = abi_type;\n};\n// }}}\n\n/** \\internal\n * Simple traits for SimdArray to easily access internal types of non-atomic SimdArray\n * types.\n */\ntemplate struct SimdArrayTraits {\n static constexpr std::size_t N0 = Common::left_size();\n static constexpr std::size_t N1 = Common::right_size();\n\n using storage_type0 = fixed_size_simd;\n using storage_type1 = fixed_size_simd;\n};\n\ntemplate \nVc_INTRINSIC_L typename SimdArrayTraits::storage_type0 &internal_data0(\n SimdArray &x) Vc_INTRINSIC_R;\ntemplate \nVc_INTRINSIC_L typename SimdArrayTraits::storage_type1 &internal_data1(\n SimdArray &x) Vc_INTRINSIC_R;\ntemplate \nVc_INTRINSIC_L const typename SimdArrayTraits::storage_type0 &internal_data0(\n const SimdArray &x) Vc_INTRINSIC_R;\ntemplate \nVc_INTRINSIC_L const typename SimdArrayTraits::storage_type1 &internal_data1(\n const SimdArray &x) Vc_INTRINSIC_R;\n\ntemplate \nVc_INTRINSIC_L V &internal_data(SimdArray &x) Vc_INTRINSIC_R;\ntemplate \nVc_INTRINSIC_L const V &internal_data(const SimdArray &x) Vc_INTRINSIC_R;\n\nnamespace Traits\n{\n// is_fixed_size_simd {{{1\ntemplate struct is_fixed_size_simd : std::false_type {\n};\ntemplate \nstruct is_fixed_size_simd> : std::true_type {\n};\ntemplate \nstruct is_fixed_size_simd> : std::true_type {\n};\n\n// is_simd_vector_internal {{{1\ntemplate \nstruct is_simd_vector_internal> : is_valid_vector_argument {};\n\n// is_simd_mask_internal {{{1\ntemplate \nstruct is_simd_mask_internal> : is_valid_vector_argument {};\n\n// is_atomic_simdarray_internal {{{1\ntemplate \nstruct is_atomic_simdarray_internal> : is_valid_vector_argument {};\ntemplate \nstruct is_atomic_simdarray_internal>\n : is_atomic_simdarray_internal> {\n};\n\n// is_atomic_simd_mask_array_internal {{{1\ntemplate \nstruct is_atomic_simd_mask_array_internal>\n : is_valid_vector_argument {\n};\ntemplate \nstruct is_atomic_simd_mask_array_internal>\n : is_atomic_simd_mask_array_internal> {\n};\n\n// is_simdarray_internal {{{1\ntemplate \nstruct is_simdarray_internal>\n : is_valid_vector_argument {\n};\ntemplate \nstruct is_simdarray_internal> : is_valid_vector_argument {\n};\n\n// is_simd_mask_array_internal {{{1\ntemplate \nstruct is_simd_mask_array_internal>\n : is_valid_vector_argument {\n};\ntemplate \nstruct is_simd_mask_array_internal>\n : is_valid_vector_argument {\n};\n\n// is_integral_internal {{{1\ntemplate \nstruct is_integral_internal, false> : std::is_integral {\n};\n\n// is_floating_point_internal {{{1\ntemplate \nstruct is_floating_point_internal, false>\n : std::is_floating_point {\n};\n\n// is_signed_internal {{{1\ntemplate \nstruct is_signed_internal, false> : std::is_signed {\n};\n\n// is_unsigned_internal {{{1\ntemplate \nstruct is_unsigned_internal, false> : std::is_unsigned {\n};\n\n// has_no_allocated_data_impl {{{1\ntemplate \nstruct has_no_allocated_data_impl> : std::true_type {\n};\n\n// }}}1\n} // namespace Traits\n\n} // namespace Vc\n\n#endif // VC_COMMON_SIMDARRAYFWD_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/simdarrayhelper.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2013-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_SIMDARRAYHELPER_H_\n#define VC_COMMON_SIMDARRAYHELPER_H_\n\n#include \"macros.h\"\n\nnamespace Vc_VERSIONED_NAMESPACE\n{\n// private_init {{{\nnamespace\n{\nstatic constexpr struct private_init_t {} private_init = {};\n} // unnamed namespace\n// }}}\n\nnamespace Common\n{\n\n/// \\addtogroup SimdArray\n/// @{\n\nnamespace Operations/*{{{*/\n{\nstruct tag {};\n#define Vc_DEFINE_OPERATION(name_) \\\n struct name_ : public tag { \\\n template \\\n Vc_INTRINSIC void operator()(V &v, Args &&... args) \\\n { \\\n v.name_(std::forward(args)...); \\\n } \\\n }\nVc_DEFINE_OPERATION(gather);\nVc_DEFINE_OPERATION(scatter);\nVc_DEFINE_OPERATION(load);\nVc_DEFINE_OPERATION(store);\nVc_DEFINE_OPERATION(setZero);\nVc_DEFINE_OPERATION(setZeroInverted);\nVc_DEFINE_OPERATION(assign);\n#undef Vc_DEFINE_OPERATION\n#define Vc_DEFINE_OPERATION(name_, code_) \\\n struct name_ : public tag { \\\n template Vc_INTRINSIC void operator()(V &v) { code_; } \\\n }\nVc_DEFINE_OPERATION(increment, ++(v));\nVc_DEFINE_OPERATION(decrement, --(v));\nVc_DEFINE_OPERATION(random, v = V::Random());\n#undef Vc_DEFINE_OPERATION\n#define Vc_DEFINE_OPERATION_FORWARD(name_) \\\n struct Forward_##name_ : public tag \\\n { \\\n template ()...))> \\\n Vc_INTRINSIC void operator()(decltype(name_(std::declval()...)) &v, \\\n Args &&... args) \\\n { \\\n v = name_(std::forward(args)...); \\\n } \\\n template ()...))> \\\n Vc_INTRINSIC void operator()(std::nullptr_t, Args && ... args) \\\n { \\\n name_(std::forward(args)...); \\\n } \\\n }\nVc_DEFINE_OPERATION_FORWARD(abs);\nVc_DEFINE_OPERATION_FORWARD(asin);\nVc_DEFINE_OPERATION_FORWARD(atan);\nVc_DEFINE_OPERATION_FORWARD(atan2);\nVc_DEFINE_OPERATION_FORWARD(cos);\nVc_DEFINE_OPERATION_FORWARD(ceil);\nVc_DEFINE_OPERATION_FORWARD(copysign);\nVc_DEFINE_OPERATION_FORWARD(exp);\nVc_DEFINE_OPERATION_FORWARD(exponent);\nVc_DEFINE_OPERATION_FORWARD(fma);\nVc_DEFINE_OPERATION_FORWARD(floor);\nVc_DEFINE_OPERATION_FORWARD(frexp);\nVc_DEFINE_OPERATION_FORWARD(isfinite);\nVc_DEFINE_OPERATION_FORWARD(isinf);\nVc_DEFINE_OPERATION_FORWARD(isnan);\nVc_DEFINE_OPERATION_FORWARD(isnegative);\nVc_DEFINE_OPERATION_FORWARD(ldexp);\nVc_DEFINE_OPERATION_FORWARD(log);\nVc_DEFINE_OPERATION_FORWARD(log10);\nVc_DEFINE_OPERATION_FORWARD(log2);\nVc_DEFINE_OPERATION_FORWARD(reciprocal);\nVc_DEFINE_OPERATION_FORWARD(round);\nVc_DEFINE_OPERATION_FORWARD(rsqrt);\nVc_DEFINE_OPERATION_FORWARD(sin);\nVc_DEFINE_OPERATION_FORWARD(sincos);\nVc_DEFINE_OPERATION_FORWARD(sqrt);\nVc_DEFINE_OPERATION_FORWARD(trunc);\nVc_DEFINE_OPERATION_FORWARD(min);\nVc_DEFINE_OPERATION_FORWARD(max);\n#undef Vc_DEFINE_OPERATION_FORWARD\ntemplate using is_operation = std::is_base_of;\n} // namespace Operations }}}\n\n/**\n * \\internal\n * Helper type to statically communicate segmentation of one vector register into 2^n parts\n * (Pieces).\n *\n * Forward declaration in common/types.h.\n */\ntemplate struct Segment/*{{{*/\n{\n static_assert(Index_ < Pieces_, \"You found a bug in Vc. Please report.\");\n\n using type = T_;\n using type_decayed = typename std::decay::type;\n static constexpr std::size_t Pieces = Pieces_;\n static constexpr std::size_t Index = Index_;\n using fixed_size_type =\n fixed_size_simd::value,\n typename type_decayed::EntryType, float>,\n type_decayed::Size / Pieces>;\n\n type data;\n\n static constexpr std::size_t EntryOffset = Index * type_decayed::Size / Pieces;\n\n // no non-const operator[] needed\n decltype(std::declval()[0]) operator[](size_t i) const { return data[i + EntryOffset]; }\n\n fixed_size_type to_fixed_size() const\n {\n return simd_cast(data);\n }\n};/*}}}*/\n\n//Segment specialization {{{\ntemplate \nstruct Segment {\n static_assert(Index_ < Pieces_, \"You found a bug in Vc. Please report.\");\n\n using type = T_ *;\n using type_decayed = typename std::decay::type;\n static constexpr size_t Pieces = Pieces_;\n static constexpr size_t Index = Index_;\n using fixed_size_type = fixed_size_simd<\n typename std::conditional::value,\n typename type_decayed::VectorEntryType, float>::type,\n type_decayed::Size / Pieces> *;\n\n type data;\n\n static constexpr std::size_t EntryOffset = Index * type_decayed::size() / Pieces;\n\n fixed_size_type to_fixed_size() const\n {\n return reinterpret_cast<\n#ifdef Vc_GCC\n // GCC might ICE if this type is declared with may_alias. If it doesn't\n // ICE it warns about ignoring the attribute.\n typename std::remove_pointer::type\n#else\n MayAlias::type>\n#endif\n *>(data) +\n Index;\n }\n\n //decltype(std::declval()[0]) operator[](size_t i) { return data[i + EntryOffset]; }\n //decltype(std::declval()[0]) operator[](size_t i) const { return data[i + EntryOffset]; }\n};/*}}}*/\n\n/** \\internal\n Template class that is used to attach an offset value to an existing type. It is used\n for IndexesFromZero construction in SimdArray. The \\c data1 constructor needs to know\n that the IndexesFromZero constructor requires an offset so that the whole data is\n constructed as a correct sequence from `0` to `Size - 1`.\n\n \\tparam T The original type that needs the offset attached.\n \\tparam Offset An integral value that determines the offset in the complete SimdArray.\n */\ntemplate struct AddOffset\n{\n constexpr AddOffset() = default;\n};\n\n// class Split {{{1\n/** \\internal\n Helper type with static functions to generically adjust arguments for the \\c data0 and\n \\c data1 members of SimdArray and SimdMaskArray.\n\n \\tparam secondOffset The offset in number of elements that \\c data1 has in the SimdArray\n / SimdMaskArray. This is essentially equal to the number of\n elements in \\c data0.\n */\ntemplate class Split\n{\n // split composite SimdArray\n template >\n static Vc_INTRINSIC auto loImpl(const SimdArray &x)\n -> decltype(internal_data0(x))\n {\n return internal_data0(x);\n }\n template >\n static Vc_INTRINSIC auto hiImpl(const SimdArray &x)\n -> decltype(internal_data1(x))\n {\n return internal_data1(x);\n }\n template >\n static Vc_INTRINSIC auto loImpl(SimdArray *x)\n -> decltype(&internal_data0(*x))\n {\n return &internal_data0(*x);\n }\n template >\n static Vc_INTRINSIC auto hiImpl(SimdArray *x)\n -> decltype(&internal_data1(*x))\n {\n return &internal_data1(*x);\n }\n\n // split atomic SimdArray\n template \n static Vc_INTRINSIC Segment loImpl(const SimdArray &x)\n {\n return {internal_data(x)};\n }\n template \n static Vc_INTRINSIC Segment hiImpl(const SimdArray &x)\n {\n return {internal_data(x)};\n }\n template \n static Vc_INTRINSIC Segment loImpl(SimdArray *x)\n {\n return {&internal_data(*x)};\n }\n template \n static Vc_INTRINSIC Segment hiImpl(SimdArray *x)\n {\n return {&internal_data(*x)};\n }\n\n // split composite SimdMaskArray\n template \n static Vc_INTRINSIC auto loImpl(const SimdMaskArray &x) -> decltype(internal_data0(x))\n {\n return internal_data0(x);\n }\n template \n static Vc_INTRINSIC auto hiImpl(const SimdMaskArray &x) -> decltype(internal_data1(x))\n {\n return internal_data1(x);\n }\n\n template \n static Vc_INTRINSIC Segment::mask_type, 2, 0> loImpl(\n const SimdMaskArray &x)\n {\n return {internal_data(x)};\n }\n template \n static Vc_INTRINSIC Segment::mask_type, 2, 1> hiImpl(\n const SimdMaskArray &x)\n {\n return {internal_data(x)};\n }\n\n // split Vector and Mask\n#ifdef Vc_IMPL_AVX\n template \n static Vc_INTRINSIC SSE::Vector loImpl(Vector &&x)\n {\n return simd_cast, 0>(x);\n }\n template \n static Vc_INTRINSIC SSE::Vector hiImpl(Vector &&x)\n {\n return simd_cast, 1>(x);\n }\n template \n static Vc_INTRINSIC SSE::Mask loImpl(Mask &&x)\n {\n return simd_cast, 0>(x);\n }\n template \n static Vc_INTRINSIC SSE::Mask hiImpl(Mask &&x)\n {\n return simd_cast, 1>(x);\n }\n#endif // Vc_IMPL_AVX\n template \n static constexpr bool is_vector_or_mask(){\n return (Traits::is_simd_vector::value && !Traits::isSimdArray::value) ||\n (Traits::is_simd_mask::value && !Traits::isSimdMaskArray::value);\n }\n template \n static Vc_INTRINSIC Segment loImpl(V &&x, enable_if()> = nullarg)\n {\n return {std::forward(x)};\n }\n template \n static Vc_INTRINSIC Segment hiImpl(V &&x, enable_if()> = nullarg)\n {\n return {std::forward(x)};\n }\n\n // split std::vector\n template \n static Vc_INTRINSIC const T *loImpl(const std::vector &x)\n {\n return x.data();\n }\n template \n static Vc_INTRINSIC const T *hiImpl(const std::vector &x)\n {\n return x.data() + secondOffset;\n }\n\n // generically split Segments\n template \n static Vc_INTRINSIC Segment loImpl(\n const Segment &x)\n {\n return {x.data};\n }\n template \n static Vc_INTRINSIC Segment hiImpl(\n const Segment &x)\n {\n return {x.data};\n }\n\n /** \\internal\n * \\name Checks for existence of \\c loImpl / \\c hiImpl\n */\n //@{\n template ()))>\n static std::true_type have_lo_impl(int);\n template static std::false_type have_lo_impl(float);\n template static constexpr bool have_lo_impl()\n {\n return decltype(have_lo_impl(1))::value;\n }\n\n template ()))>\n static std::true_type have_hi_impl(int);\n template static std::false_type have_hi_impl(float);\n template static constexpr bool have_hi_impl()\n {\n return decltype(have_hi_impl(1))::value;\n }\n //@}\n\npublic:\n /** \\internal\n * \\name with Operations tag\n *\n * These functions don't overload on the data parameter. The first parameter (the tag) clearly\n * identifies the intended function.\n */\n //@{\n template \n static Vc_INTRINSIC const U *lo(Operations::gather, const U *ptr)\n {\n return ptr;\n }\n template \n static Vc_INTRINSIC const U *hi(Operations::gather, const U *ptr)\n {\n return ptr + secondOffset;\n }\n template ::value>>\n static Vc_ALWAYS_INLINE decltype(loImpl(std::declval()))\n lo(Operations::gather, U &&x)\n {\n return loImpl(std::forward(x));\n }\n template ::value>>\n static Vc_ALWAYS_INLINE decltype(hiImpl(std::declval()))\n hi(Operations::gather, U &&x)\n {\n return hiImpl(std::forward(x));\n }\n template \n static Vc_INTRINSIC const U *lo(Operations::scatter, const U *ptr)\n {\n return ptr;\n }\n template \n static Vc_INTRINSIC const U *hi(Operations::scatter, const U *ptr)\n {\n return ptr + secondOffset;\n }\n //@}\n\n /** \\internal\n \\name without Operations tag\n\n These functions are not clearly tagged as to where they are used and therefore\n behave differently depending on the type of the parameter. Different behavior is\n implemented via overloads of \\c loImpl and \\c hiImpl. They are not overloads of \\c\n lo and \\c hi directly because it's hard to compete against a universal reference\n (i.e. an overload for `int` requires overloads for `int &`, `const int &`, and `int\n &&`. If one of them were missing `U &&` would win in overload resolution).\n */\n //@{\n template \n static Vc_ALWAYS_INLINE decltype(loImpl(std::declval())) lo(U &&x)\n {\n return loImpl(std::forward(x));\n }\n template \n static Vc_ALWAYS_INLINE decltype(hiImpl(std::declval())) hi(U &&x)\n {\n return hiImpl(std::forward(x));\n }\n\n template \n static Vc_ALWAYS_INLINE enable_if(), U> lo(U &&x)\n {\n return std::forward(x);\n }\n template \n static Vc_ALWAYS_INLINE enable_if(), U> hi(U &&x)\n {\n return std::forward(x);\n }\n //@}\n};\n\n// actual_value {{{1\ntemplate \nstatic Vc_INTRINSIC const V &actual_value(Op, const SimdArray &x)\n{\n return internal_data(x);\n}\ntemplate \nstatic Vc_INTRINSIC V *actual_value(Op, SimdArray *x)\n{\n return &internal_data(*x);\n}\ntemplate \nstatic Vc_INTRINSIC typename Segment::fixed_size_type actual_value(\n Op, Segment &&seg)\n{\n return seg.to_fixed_size();\n}\n\ntemplate \nstatic Vc_INTRINSIC const typename V::Mask &actual_value(Op, const SimdMaskArray &x)\n{\n return internal_data(x);\n}\ntemplate \nstatic Vc_INTRINSIC typename V::Mask *actual_value(Op, SimdMaskArray *x)\n{\n return &internal_data(*x);\n}\n\n// unpackArgumentsAuto {{{1\n/**\\internal\n * \\name unpackArgumentsAuto\n *\n * Search for the right amount of SimdArray \"unpacking\" (via actual_value) to match the\n * interface of the function to be called.\n *\n * The compiler can figure this out for us thanks to SFINAE. The approach is to have a\n * number \\c I that determines the indexes of the arguments to be transformed via\n * actual_value. Each bit of \\c I identifies an argument. unpackArgumentsAuto starts the\n * recursion with `I = 0`, i.e. no actual_value transformations. If the overload calling\n * \\c op is unavailable due to a substitution failure \\c I is incremented and the function\n * recurses. Otherwise there are two unpackArgumentsAutoImpl functions in the overload\n * set. The first argument (\\c int / \\c float) leads to a preference of the function\n * calling \\c op, thus ending the recursion.\n */\n///@{\n\n///\\internal transforms \\p arg via actual_value\ntemplate \nVc_INTRINSIC decltype(actual_value(std::declval(), std::declval()))\nconditionalUnpack(std::true_type, Op op, Arg &&arg)\n{\n return actual_value(op, std::forward(arg));\n}\n///\\internal forwards \\p arg to its return value\ntemplate \nVc_INTRINSIC Arg conditionalUnpack(std::false_type, Op, Arg &&arg)\n{\n return std::forward(arg);\n}\n\n///\\internal true-/false_type that selects whether the argument with index B should be unpacked\ntemplate \nstruct selectorType : public std::integral_constant {\n};\n\n///\\internal ends the recursion, transforms arguments, and calls \\p op\ntemplate \nVc_INTRINSIC decltype(std::declval()(std::declval(),\n conditionalUnpack(selectorType(),\n std::declval(),\n std::declval())...))\nunpackArgumentsAutoImpl(int, index_sequence, Op op, R &&r, Args &&... args)\n{\n op(std::forward(r),\n conditionalUnpack(selectorType(), op, std::forward(args))...);\n}\n\n///\\internal the current actual_value calls don't work: recurse to I + 1\ntemplate \nVc_INTRINSIC enable_if<(I <= (size_t(1) << sizeof...(Args))), void> unpackArgumentsAutoImpl(\n float, index_sequence is, Op op, R &&r, Args &&... args)\n{\n // if R is nullptr_t then the return type cannot enforce that actually any unwrapping\n // of the SimdArray types happens. Thus, you could get an endless loop of the\n // SimdArray function overload calling itself, if the index goes up to (1 <<\n // sizeof...(Args)) - 1 (which means no argument transformations via actual_value).\n static_assert(\n I < (1 << sizeof...(Args)) - (std::is_same::value ? 1 : 0),\n \"Vc or compiler bug. Please report. Failed to find a combination of \"\n \"actual_value(arg) transformations that allows calling Op.\");\n unpackArgumentsAutoImpl(int(), is, op, std::forward(r),\n std::forward(args)...);\n}\n\n#ifdef Vc_ICC\ntemplate struct IccWorkaround {\n using type = void;\n};\ntemplate struct IccWorkaround<2, Ts...> {\n using type = typename std::remove_pointer>::type>::type>::type;\n};\n#endif\n\n///\\internal The interface to start the machinery.\ntemplate \nVc_INTRINSIC void unpackArgumentsAuto(Op op, R &&r, Args &&... args)\n{\n#ifdef Vc_ICC\n // ugly hacky workaround for ICC:\n // The compiler fails to do SFINAE right on recursion. We have to hit the right\n // recursionStart number from the start.\n const int recursionStart =\n Traits::isSimdArray<\n typename IccWorkaround::type>::value &&\n (std::is_same::value ||\n std::is_same::value)\n ? 2\n : 0;\n#else\n const int recursionStart = 0;\n#endif\n unpackArgumentsAutoImpl(\n int(), make_index_sequence(), op, std::forward(r),\n std::forward(args)...);\n}\n///@}\n\n//}}}1\n///@}\n} // namespace Common\n} // namespace Vc\n\n#endif // VC_COMMON_SIMDARRAYHELPER_H_\n\n// vim: foldmethod=marker\n" }, { "path": "3rdparty/Vc/Vc/common/simdize.h", "content": "/* This file is part of the Vc library. {{{\nCopyright © 2014-2015 Matthias Kretz \n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n * Neither the names of contributing organizations nor the\n names of its contributors may be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n}}}*/\n\n#ifndef VC_COMMON_SIMDIZE_H_\n#define VC_COMMON_SIMDIZE_H_\n\n#include \n#include \n\n#include \"../Allocator\"\n#include \"interleavedmemory.h\"\n\n/*!\n\\addtogroup Simdize\n\nAutomatic type vectorization.\n\nStruct Vectorization\n======================\n\nThe `Vc::simdize` expression transforms the type \\c T to a vectorized type. This requires the type\n\\c T to be a class template instance or an arithmetic type.\n\nExample:\nFirst, we declare a class template for a three-dimensional point. The template parameter \\c T\ndetermines the type of the members and is \\c float in the scalar (classical) case.\n\\code\ntemplate struct PointTemplate\n{\n T x, y, z;\n\n // Declares tuple_size and makes the members accessible via get(point), allowing\n // the simdize implementation to convert between Point and PointV (see below).\n Vc_SIMDIZE_INTERFACE((x, y, z));\n\n PointTemplate(T xx, T yy, T zz) : x{xx}, y{yy}, z{zz} {};\n\n // The following function will automatically be vectorized in the PointV type.\n T distance_to_origin() const {\n using std::sqrt;\n return sqrt(x * x + y * y + z * z);\n }\n};\n\\endcode\n\nIn the following we create a type alias for the scalar type, which simply means instantiating\n\\c PointTemplate with \\c float. The resulting type can then be transformed with \\ref simdize.\n\\code\nusing Point = PointTemplate; // A simple struct with three floats and two functions.\nusing PointV = Vc::simdize; // The vectorization of Point stores three float_v and thus\n // float_v::size() Points.\n\\endcode\n\nThe following shows a code example using the above \\c Point and \\c PointV types.\n\\code\nPointV pv = Point{0.f, 1.f, 2.f}; // Constructs a PointV containing PointV::size()\n // copies of Point{0, 1, 2}.\nfor (int i = 1; i < int(pv.size()); ++i) {\n assign(pv, i, {i + 0.f, i + 1.f, i + 2.f});\n}\n\nconst Vc::float_v l = pv.distance_to_origin();\nstd::cout << l << '\\n';\n// prints [2.23607, 3.74166, 5.38516, 7.07107, 8.77496, 10.4881, 12.2066, 13.9284] with\n// float_v::size() == 8\n\nconst Point most_distant = extract(pv, (l.max() == l).firstOne());\nstd::cout << '(' << most_distant.x << \", \" << most_distant.y << \", \" << most_distant.z << \")\\n\";\n// prints (7, 8, 9) with float_v::size() == 8\n\\endcode\n\nIterator Vectorization\n======================\n\n`Vc::simdize` can also be used to turn an iterator type into a new iterator type with `Vc::simdize` as its `value_type`.\nNote that `Vc::simdize` turns into `Vc::Vector`, which makes it easy to iterate over a given container of builtin arithmetics using `Vc::Vector`.\n\\code\nvoid classic(const std::vector &data) {\n using It = std::vector::const_iterator;\n const It end = data.end();\n for (It it = data.begin(); it != end; ++it) {\n Point x = *it;\n do_something(x);\n }\n}\n\nvoid vectorized(const std::vector &data) {\n using It = Vc::simdize::const_iterator>;\n const It end = data.end();\n for (It it = data.begin(); it != end; ++it) {\n Vc::simdize x = *it; // i.e. PointV\n do_something(x);\n }\n}\n\\endcode\n\n */\nnamespace Vc_VERSIONED_NAMESPACE\n{\n/**\\internal\n * \\ingroup Simdize\n * This namespace contains all the required code for implementing simdize. None of this\n * code should be directly accessed by users, though the unit test for simdize\n * certainly may look into some of the details if necessary.\n */\nnamespace SimdizeDetail // {{{\n{\n/**\n * \\addtogroup Simdize\n * @{\n */\nusing std::is_same;\nusing std::is_base_of;\nusing std::false_type;\nusing std::true_type;\nusing std::iterator_traits;\nusing std::conditional;\nusing std::size_t;\n\n/**\\internal\n * Typelist is a simple helper class for supporting multiple parameter packs in one class\n * template.\n */\ntemplate struct Typelist;\n\n/**\\internal\n * The Category identifies how the type argument to simdize has to be transformed.\n */\nenum class Category {\n ///\\internal No transformation\n NoTransformation,\n ///\\internal simple Vector transformation\n ArithmeticVectorizable,\n ///\\internal transform an input iterator to return vectorized entries\n InputIterator,\n ///\\internal transform a forward iterator to return vectorized entries\n OutputIterator,\n ///\\internal transform an output iterator to return vectorized entries\n ForwardIterator,\n ///\\internal transform a bidirectional iterator to return vectorized entries\n BidirectionalIterator,\n ///\\internal transform a random access iterator to return vectorized entries\n RandomAccessIterator,\n ///\\internal transform a class template recursively\n ClassTemplate\n};\n\n/**\\internal\n * iteratorCategories(int()) returns whether iterator_traits::iterator_category is a\n * valid type and whether it is derived from RandomAccessIterator or ForwardIterator.\n */\ntemplate \nconstexpr Category iteratorCategories(int, ItCat * = nullptr)\n{\n return is_base_of::value\n ? Category::RandomAccessIterator\n : is_base_of::value\n ? Category::BidirectionalIterator\n : is_base_of::value\n ? Category::ForwardIterator\n : is_base_of::value\n ? Category::OutputIterator\n : is_base_of::value\n ? Category::InputIterator\n : Category::NoTransformation;\n}\n/**\\internal\n * This overload is selected for pointer types => RandomAccessIterator.\n */\ntemplate \nconstexpr enable_if::value, Category> iteratorCategories(float)\n{\n return Category::RandomAccessIterator;\n}\n/**\\internal\n * This overload is selected if T does not work with iterator_traits.\n */\ntemplate constexpr Category iteratorCategories(...)\n{\n return Category::NoTransformation;\n}\n\n/**\\internal\n * Simple trait to identify whether a type T is a class template or not.\n */\ntemplate struct is_class_template : public false_type\n{\n};\ntemplate