• <div><p>The scaling factor of the drift vector, used in importance sampling, may deviate from the intended implementation of "eq. (34) *tau in Umrigar, JCP 99, 2865 (1993)". The deviation ...
  • on partition tables to allow real disk capacity to deviate from BIOS CHS data. Allows CF disks to be fully utilized on old systems with a fixed set of BIOS-supported disk drives. This closes #730. ...
  • 2547&topicid=14813 <p>For “Time indicators (media)”, the style guide requires that there be no leading zeros in the number of minutes, and no visible zero ('0') for the number of ...
  • <div><p>Hey Folks, <p>in Amazon the most common place to store large data chunks are sadly not in /opt/. <p>if i specify: <pre><code> default['graphite']['base_dir'...
  • <div><p>Currently QGC displays the waypoints as set up by the user. In reality however, the autopilot might fly a slightly different route. <p>Reasons for this are: * Trajectory smoothing ...
  • <div><p>There are two versions of cisco-xe-openconfig-interfaces-deviation.... We need a way to let --check-update-from consider deviate/augment.</p><p>该提问来源于开源项目:mbj4668/pyang</p></div>
  • <p>I reimplemented the Deviate classes a bit to put the primary class definitions in python and just use the C++ classes as back-end implementations. This also let me remove the numpy handling...
  • <div><p>Useful for when we have an arbitrary (e.g. realistic) P(e) function for the ellipticity.</p><p>该提问来源于开源项目:GalSim-developers/GalSim</p></div>
  • <p>I have very strong suspicion that kube-state-metrics never does resync and hence a long-running instance will deviate from the reality quite dramatically. At least this is what we see in production...
  • <div><p>Unlike Opera, when you fill search box and you're not looking at a blank ...t see wherefore deviate from the ideal? ;-) </p><p>该提问来源于开源项目:OtterBrowser/otter-browser</p></div>
  • <div><p>SBProfile code Poisson.cpp uses some NR routines (gammp, gammq, gser, gcf) with very little alteration to build a Poisson deviate from a uniform deviate. Mike gave some references for ...
  • The new node comes from a different module and therefore has a different prefix, but <code>Entry.Dir</code> only cares about unprefixed names. So when the deviations are applied, it wipes out the new...
  • re using <code>deku</code> in a OOP way, but if you try to deviate from the model (for example by extending it with <a href="https://github.com/yoshuawuyts/deku-event">event emitters) this becomes ...
  • <p>My opinion: in general one should use the upstream default (here proxmox) if there is no good reason to deviate from it. If there is a good reason to change the default that applies in general, ask...
  • Python is from /usr/local/EPD/epd-7.1.2/include/python2.7 Using the following (non-default) scons options: CXX = g++ TMV_DIR = /home/browe/local/32 BOOST_DIR = /home/browe/local...
  • But, by doing so, we would deviate from 'the Silex way'. This might not seem like a big deal now, but perhaps we would bump into unforeseen consequences when Silex matures. <p>Technically, ...
  • t be a project <em>policy, it could just be a norm which anyone could choose to deviate from? <p>I encourage all contributors - or any interested parties - to chime in with their opinions. I'd ...
  • <p>More assertions should be made after this - we already deviate from Anki Desktop and I deemed it not to be worth the effort to add additional test cases</p><p>该提问来源于开源项目:...
  • <div><p><strong>Author: deveee</strong></p> ...<p>Migrated-From: https://sourceforge.net/apps/trac/supertuxkart/ticket/895</p><p>该提问来源于开源项目:supertuxkart/stk-code</p></div>
  • An inevitable consequence is that the initial containing block deviates from the visual viewport in the initial un-zoomed state (zero pinch-zoom), and this results in content that would ordinarily be...
  • In the field of wireless sensor networks, those measurements that significantly deviate from the normal patternof sensed data are considered as outliers. The potential sources of outliers include ...
  • 四六级词汇

    2019-05-22 22:14:57
    四六级词汇学习笔记 英语单词有前缀和后缀,前缀一般改变词义,后缀一般改变词性。 前缀示例: ...deviate from --偏离(deviate脱离) 前缀:de -> down(下降) decrease(减少) decline(下降) ...




    deriver from --源自于
    deviate from --偏离(deviate脱离)
    前缀:de -> down(下降)
    derive from小河下降,小河从哪下降,即小河源自哪里,所以derive from表示源自于
    decline(n.下降,vt 婉拒)
    (同义词 refus ,reject)
    前缀re 表示again再一次 或者 back返回
    retell 再讲一遍
    return 返回,回报
    词根fuse = flow 表示流动
    refuse 表示流回去(拒绝)
    reject 扔回去(强烈的拒绝)

    steam from 也表示源自于的意思
    steam 名词-根茎
    originate from 源自于


    counter :计算器,计数器,柜台
    (OTC:over the counter)




    fluctuate 起伏不定
    2、动词,例如:graduate 毕业(动词)
    后缀:ent=ant 表示形容词或者名词后缀
    名词 液体,形容词流动的
    反义词 solid
    前缀:in 表在里面

  • Cadet Handbook 2014

    2019-01-22 16:13:58
    The procedures included in this handbook apply unless leadership makes a decision to deviate from them based on METT-TC. Deviations from this handbook must be narrow and apply only to specific ...
  • <div><p>Let us know if you had to significantly deviate from the instructions!</p><p>该提问来源于开源项目:rust-embedded/embedonomicon</p></div>
  • Python code standard

    2020-08-13 09:36:49
    Generally, followPEP 257for docstrings. We’ll only describe the ways ...CKAN docstrings deviate from PEP 257 in a couple of ways: We use'''triplesinglequotes'''around docstrings, not"""tripledoublequ
    • Module Level Dunder Names

       Module level "dunders" (i.e. names with two leading and two trailing underscores) such as __all__, __author__, __version__, etc.
       should be placed after the module docstring but before any import statements except from __future__ imports.
       Python mandates that future-imports must appear in the module before any other code except docstrings:
    • Whitespace in Expressions and Statements Pet Peeves

    Avoid extraneous whitespace in the following situations:

    • Immediately inside parentheses, brackets or braces.

       Yes: spam(ham[1], {eggs: 2})
       No:  spam( ham[ 1 ], { eggs: 2 } )
    • Between a trailing comma and a following close parenthesis.

       Yes: foo = (0,)
       No:  bar = (0, )
    • Immediately before a comma, semicolon, or colon:

       Yes: if x == 4: print x, y; x, y = y, x
       No:  if x == 4 : print x , y ; x , y = y , x
    • However, in a slice the colon acts like a binary operator, and should have equal amounts on either side (treating it as the operator with the lowest priority). In an extended slice, both colons must have the same amount of spacing applied. Exception: when a slice parameter is omitted, the space is omitted.

       ham[1:9], ham[1:9:3], ham[:9:3], ham[1::3], ham[1:9:]
       ham[lower:upper], ham[lower:upper:], ham[lower::step]
       ham[lower+offset : upper+offset]
       ham[: upper_fn(x) : step_fn(x)], ham[:: step_fn(x)]
       ham[lower + offset : upper + offset]
       ham[lower + offset:upper + offset]
       ham[1: 9], ham[1 :9], ham[1:9 :3]
       ham[lower : : upper]
       ham[ : upper]
    • Immediately before the open parenthesis that starts the argument list of a function call:

       Yes: spam(1)
       No:  spam (1)
    • Immediately before the open parenthesis that starts an indexing or slicing:

       Yes: dct['key'] = lst[index]
       No:  dct ['key'] = lst [index]
    • More than one space around an assignment (or other) operator to align it with another.

       x = 1
       y = 2
       long_variable = 3
       x             = 1
       y             = 2
       long_variable = 3
    • Indentation

    Use 4 spaces per indentation level.
    Continuation lines should align wrapped elements either vertically using Python's implicit line joining inside parentheses, brackets and braces, or using a hanging indent [7]. When using a hanging indent the following should be considered; there should be no arguments on the first line and further indentation should be used to clearly distinguish itself as a continuation line.
    # Aligned with opening delimiter.
    foo = long_function_name(var_one, var_two,
                             var_three, var_four)
    # More indentation included to distinguish this from the rest.
    def long_function_name(
            var_one, var_two, var_three,
    # Hanging indents should add a level.
    foo = long_function_name(
        var_one, var_two,
        var_three, var_four)
    # Arguments on first line forbidden when not using vertical alignment.
    foo = long_function_name(var_one, var_two,
        var_three, var_four)
    # Further indentation required as indentation is not distinguishable.
    def long_function_name(
        var_one, var_two, var_three,
    The 4-space rule is optional for continuation lines.
    # Hanging indents *may* be indented to other than 4 spaces.
    foo = long_function_name(
      var_one, var_two,
      var_three, var_four)
    When the conditional part of an if-statement is long enough to require that it be written across multiple lines, it's worth noting that the combination of a two character keyword (i.e. if), plus a single space, plus an opening parenthesis creates a natural 4-space indent for the subsequent lines of the multiline conditional. This can produce a visual conflict with the indented suite of code nested inside the if-statement, which would also naturally be indented to 4 spaces. This PEP takes no explicit position on how (or whether) to further visually distinguish such conditional lines from the nested suite inside the if-statement. Acceptable options in this situation include, but are not limited to:
    # No extra indentation.
    if (this_is_one_thing and
    # Add a comment, which will provide some distinction in editors
    # supporting syntax highlighting.
    if (this_is_one_thing and
        # Since both conditions are true, we can frobnicate.
    # Add some extra indentation on the conditional continuation line.
    if (this_is_one_thing
            and that_is_another_thing):
    (Also see the discussion of whether to break before or after binary operators below.)
    The closing brace/bracket/parenthesis on multiline constructs may either line up under the first non-whitespace character of the last line of list, as in:
    my_list = [
        1, 2, 3,
        4, 5, 6,
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    or it may be lined up under the first character of the line that starts the multiline construct, as in:
    my_list = [
        1, 2, 3,
        4, 5, 6,
    result = some_function_that_takes_arguments(
        'a', 'b', 'c',
        'd', 'e', 'f',
    • Tabs or Spaces?

       Spaces are the preferred indentation method.
       Tabs should be used solely to remain consistent with code that is already indented with tabs.
       Python 3 disallows mixing the use of tabs and spaces for indentation.
       Python 2 code indented with a mixture of tabs and spaces should be converted to using spaces exclusively.
       When invoking the Python 2 command line interpreter with the -t option, it issues warnings about code that illegally mixes tabs and spaces. When using -tt these warnings become errors. These options are highly recommended!
    • Maximum Line Length

        Limit all lines to a maximum of 79 characters.
        For flowing long blocks of text with fewer structural restrictions (docstrings or comments), the line length should be limited to 72 characters.
        The Python standard library is conservative and requires limiting lines to 79 characters (and docstrings/comments to 72).
        The preferred way of wrapping long lines is by using Python's implied line continuation inside parentheses, brackets and braces. Long lines can be broken over multiple lines by wrapping expressions in parentheses. These should be used in preference to using a backslash for line continuation.
        Backslashes may still be appropriate at times. For example, long, [multiple with-statements](https://www.python.org/dev/peps/pep-0008/#multiline-if-statements) cannot use implicit continuation, so backslashes are acceptable:
        with open('/path/to/some/file/you/want/to/read') as file_1, \
            open('/path/to/some/file/being/written', 'w') as file_2:
       (See the previous discussion on multiline if-statements for further thoughts on the indentation of such multiline with-statements.)
       Another such case is with assert statements.
       Make sure to indent the continued line appropriately.
    • Should a Line Break Before or After a Binary Operator?

    Following the tradition from mathematics usually results in more readable code:
    # Yes: easy to match operators with operands
    income = (gross_wages
              + taxable_interest
              + (dividends - qualified_dividends)
              - ira_deduction
              - student_loan_interest)
    In Python code, it is permissible to break before or after a binary operator, as long as the convention is consistent locally. For new code Knuth's style is suggested.
    • Blank Lines

      Surround top-level function and class definitions with two blank lines.
      Method definitions inside a class are surrounded by a single blank line.
      Extra blank lines may be used (sparingly) to separate groups of related functions. Blank lines may be omitted between a bunch of related one-liners (e.g. a set of dummy implementations).
      Use blank lines in functions, sparingly, to indicate logical sections.
      Python accepts the control-L (i.e. ^L) form feed character as whitespace; Many tools treat these characters as page separators, so you may use them to separate pages of related sections of your file. Note, some editors and web-based code viewers may not recognize control-L as a form feed and will show another glyph in its place.
    • Use single quotes

       Use single-quotes for string literals, e.g. 'my-identifier', but use double-quotes for strings that are likely to contain single-quote characters as part of the string itself (such as error messages, or any strings containing natural language), e.g. "You've got an error!".
      Single-quotes are easier to read and to type, but if a string contains single-quote characters then double-quotes are better than escaping the single-quote characters or wrapping the string in double single-quotes.
      We also use triple single-quotes for docstrings, see http://docs.ckan.org/en/latest/contributing/python.html#docstrings.
    • Imports

      • Avoid creating circular imports by only importing modules more specialized than the one you are editing.

        CKAN often uses code imported into a data structure instead of importing names directly. For example CKAN controllers only use get_action to access logic functions. This allows customization by CKAN plugins.

      • Don’t use from module import *. Instead list the names you need explicitly:

          from module import name1, name2

      Use parenthesis around the names if they are longer than one line:

       	from module import (name1, name2, ...
       name12, name13)
      • Most of the current CKAN code base imports just the modules and then accesses names with module.name(http://module.name/). This allows circular imports in some cases and may still be necessary for exsiting code, but is not recommended for new code.

      • Make all imports at the start of the file, after the module docstring. Imports should be grouped in the following order:

      Standard library imports
      Third-party imports
      CKAN imports

    • Logging

    We use the Python standard library’s logging module to log messages in CKAN, e.g.:
    import logging
    logger = logging.getLogger(__name__)
    logger.debug('some debug message')
    When logging:
    Keep log messages short.
    Don’t include object representations in the log message. It is useful to include a domain model identifier where appropriate.
    Choose an appropriate log-level (DEBUG, INFO, ERROR, WARNING or CRITICAL, see Python’s Logging HOWTO).
    • String formatting
      Don’t use the old %s style string formatting, e.g. “i am a %s” % sub. This kind of string formatting is not helpful for internationalization.

      Use the new .format() method instead, and give meaningful names to each replacement field, for example:
      _(’ … {foo} … {bar} …’).format(foo=‘foo-value’, bar=‘bar-value’)

      CKAN strives to only use Unicode internally (via the unicode type) and to convert to/from ASCII at the interface to other systems and libraries if necessary.

    • Docstrings
      We want CKAN’s docstrings to be clear and easy to read for programmers who are smart and competent but who may not know a lot of CKAN technical jargon and whose first language may not be English. We also want it to be easy to maintain the docstrings and keep them up to date with the actual behaviour of the code as it changes over time. So:

      All modules and all public functions, classes and methods exported by a module should normally have docstrings (see PEP 257).

      - Keep docstrings short, describe only what’s necessary and no more.
      - Keep docstrings simple: use plain, concise English.
      - Try to avoid repetition.
    • PEP 257 (Docstring Conventions)
      Generally, follow PEP 257 for docstrings. We’ll only describe the ways that CKAN differs from or extends PEP 257 below.

      CKAN docstrings deviate from PEP 257 in a couple of ways:

      • We use ‘’‘triple single quotes’’’ around docstrings, not “”“triple double quotes”"" (put triple single quotes around one-line docstrings as well as multi-line ones, it makes them easier to expand later)
      • We use Sphinx domain object cross-references to cross-reference to other code objects (see below)
      • We use Sphinx directives for documenting parameters, exceptions and return values (see below)
    • Referencing other code objects with :py:

    If you want to refer to another Python or JavaScript module, function or class etc. in a docstring (or from a .rst file), use Sphinx domain object cross-references, for example:
    See :py:mod:`ckan.lib.helpers`.
    See :py:func:`ckan.logic.action.create.package_create`.
    See :py:class:`ckan.logic.NotFound`.
    For the full list of types of cross-reference, see the Sphinx docs.
    These kinds of cross-references can also be used to reference other types of object besides Python objects,
    for example JavaScript objects or even command-line scripts and options and environment variables. See the Sphinx docs for the full details.
    Cross-referencing objects like this means that Sphinx will style the reference with the right CSS, and hyperlink the reference to the docs for the referenced object.
    Sphinx can also generate error messages when non-existent objects are referenced, which helps to keep the docs up to date as the code changes.
    Sphinx will render a cross-reference like :py:func:`ckan.logic.action.create.package_create` as the full name of the function: ckan.logic.action.create.package_create().
    If you want the docs to contain only the local name of the function (e.g. just package_create()), put a ~ at the start:
    (But you should always use the fully qualified name in your docstring or *.rst file.)
    • Documenting exceptions raised with :raises
    There are a few guidelines that CKAN code should follow regarding exceptions:
    All public functions that CKAN exports for third-party code to use should document any exceptions they raise. See below for how to document exceptions raised.
    For example the template helper functions in ckan.lib.helpers, anything imported into ckan.plugins.toolkit, and all of the action API functions defined in ckan.logic.action, should list exceptions raised in their docstrings.
    This is because CKAN themes, extensions and API clients need to be able to call CKAN code without crashing, so they need to know what exceptions they should handle (and extension developers shouldn’t have to understand the CKAN core source code).
    On the other hand, internal functions that are only used within CKAN shouldn’t list exceptions in their docstrings.
    This is because it would be difficult to keep all the exception lists up to date with the actual code behaviour, so the docstrings would become more misleading than useful.
    Code should only raise exceptions from within its allowed set.
    Each module in CKAN has a set of zero or more exceptions, defined somewhere near the module, that code in that module is allowed to raise. For example ckan/logic/__init__.py defines a number of exception types for code in ckan/logic/ to use. CKAN code should never raise exceptions types defined elsewhere in CKAN, in third-party code or in the Python standard library.
    All code should catch any exceptions raised by called functions, and either handle the exception, re-raise the exception (if it’s from the code’s set of allowed exception types), or wrap the exception in an allowed exception type and re-raise it.
    This is to make it easy for a CKAN core developer to look at the source code of an internal function, scan it for the keyword raise, and see what types of exception the function may raise, so they know what exceptions they need to catch if they’re going to call the function. Developers shouldn’t have to read the source of all the functions that a function calls (and the functions they call…) to find out what exceptions they needs to catch to call a function without crashing.
    Use :raises: to document exceptions raised by public functions. The docstring should say what type of exception is raised and under what conditions. Use :py:class: to reference exception types. For example:
    def member_list(context, data_dict=None):
     '''Return the members of a group.
     ... (parameters and return values documented here) ...
     :raises: :py:class:`ckan.logic.NotFound`: if the group doesn't exist
    • Sphinx field lists
    Use Sphinx field lists for documenting the parameters, exceptions and returns of functions:
    Use :param and :type to describe each parameter
    Use :returns and :rtype to describe each return
    Use :raises to describe each exception raised
    Example of a short docstring:
    def packages(self):
        '''Return a list of all packages that have this tag, sorted by name.
     :rtype: list of ckan.model.package.Package objects
    Example of a longer docstring:
    def search_by_name(cls, search_term, vocab_id_or_name=None):
        '''Return all tags whose names contain a given string.
     By default only free tags (tags which do not belong to any vocabulary)
     are returned. If the optional argument ``vocab_id_or_name`` is given
     then only tags from that vocabulary are returned.
     :param search_term: the string to search for in the tag names
     :type search_term: string
     :param vocab_id_or_name: the id or name of the vocabulary to look in
     (optional, default: None)
     :type vocab_id_or_name: string
     :returns: a list of tags that match the search term
     :rtype: list of ckan.model.tag.Tag objects
    The phrases that follow :param foo:, :type foo:, or :returns: should not start with capital letters or end with full stops. These should be short phrases and not full sentences. If more detail is required put it in the function description instead.
    Indicate optional arguments by ending their descriptions with (optional) in brackets. Where relevant also indicate the default value: (optional, default: 5).
    You can also use a little inline reStructuredText markup in docstrings, e.g. *stars for emphasis* or ``double-backticks for literal text``
    • Action API docstrings
    Docstrings from CKAN’s action API are processed with autodoc and included in the API chapter of CKAN’s documentation. The intended audience of these docstrings is users of the CKAN API and not (just) CKAN core developers.
    In the Python source each API function has the same two arguments (context and data_dict), but the docstrings should document the keys that the functions read from data_dict and not contextand data_dict themselves, as this is what the user has to POST in the JSON dict when calling the API.
    Where practical, it’s helpful to give examples of param and return values in API docstrings.
    CKAN datasets used to be called packages and the old name still appears in the source, e.g. in function names like package_list(). When documenting functions like this write dataset not package, but the first time you do this put package after it in brackets to avoid any confusion, e.g.
    def package_show(context, data_dict):
     '''Return the metadata of a dataset (package) and its resources.
    Example of a ckan.logic.action API docstring:
    def vocabulary_create(context, data_dict):
     '''Create a new tag vocabulary.
     You must be a sysadmin to create vocabularies.
     :param name: the name of the new vocabulary, e.g. ``'Genre'``
     :type name: string
     :param tags: the new tags to add to the new vocabulary, for the format of
     tag dictionaries see ``tag_create()``
     :type tags: list of tag dictionaries
     :returns: the newly-created vocabulary
     :rtype: dictionary

    There are various tools that can help you to check your Python code for PEP8 conformance and general code quality. We recommend using them:

    pep8 checks your Python code against some of the style conventions in PEP 8. As mentioned above, only perform style clean-ups on master to help avoid spurious merge conflicts.
    pylint analyzes Python source code looking for bugs and signs of poor quality.
    pyflakes also analyzes Python programs to detect errors.
    flake8 combines both pep8 and pyflakes into a single tool.
    Syntastic is a Vim plugin with support for flake8, pyflakes and pylint.

  • MISRA C Rule Checker

    2009-02-11 17:06:46
    SQMlint statically checks C source codes to find codes that deviate from any of MISRA C1 rules. The MISRA C rules are guidelines and can be used as inspection items of source code review. Some ...
  • chromebook刷机Chromebooks are great because they’re simple, secure, and ... If you’re the type who likes to tinker, however, you can deviate from that stable bit by enabling experimental features. ...


    Chromebooks are great because they’re simple, secure, and stable. If you’re the type who likes to tinker, however, you can deviate from that stable bit by enabling experimental features.

    Chromebook很棒,因为它们简单,安全且稳定。 但是,如果您是喜欢修改的类型,则可以通过启用实验功能来偏离稳定的位置。

    While some of the tweaks we cover here are specific to Chromebooks, others are also available in the Chrome browser for Windows, Mac, and Linux. We’ll specify which as we discuss them. Time to get your hands dirty!

    虽然我们在此介绍的某些调整是特定于Chromebook的,但其他调整也可以在Windows,Mac和Linux的Chrome浏览器中找到。 我们将在讨论它们时指定它们。 是时候弄脏你的双手了!

    调整隐藏的标志 (Tweak Hidden Flags)

    As features are in development for Chrome, they’re often added in as “flags”—hidden tweaks that are almost ready for primetime, but still may need a bit of work. These flags are available on both Chrome and Chrome OS.

    由于Chrome的功能正在开发中,因此通常会将它们添加为“标志”,这些隐含的调整几乎已经准备就绪,但可能仍需要一些工作。 这些标志在Chrome和Chrome操作系统上均可用。

    Before you start clicking and tweaking your little heart out, remember that most of these features are not finished. They’re mostly there, but not completely. As a result, these flags can cause your browser or computer to become unstable—and the more flags you tweak, the higher the chances of this happening. We’re not trying to scare you away from trying things out, of course, but you should keep your expectations in check.

    在开始单击并调整您的小心脏之前,请记住,其中大多数功能尚未完成。 他们大多在那儿,但并不完全。 结果,这些标志可能导致您的浏览器或计算机变得不稳定-并且您调整的标志越多,发生这种情况的机会就越大。 当然,我们并不是想吓you您尝试,但您应该控制自己的期望。

    Also note that Google can remove any of these features at any time, so it’s best to not get too attached. There’s a chance any particular flag could simply disappear after the next update. It doesn’t happen very often, but it does happen.

    另请注意,Google可以随时删除所有这些功能,因此最好不要太过重视。 在下次更新后,任何特定的标志都有可能简单地消失。 它不会经常发生,但是确实会发生。

    If you’re still interested in seeing what’s going on behind the scenes, open a new browser tab and type the following:



    This address opens the flags menu, where you’ll find all sorts of new goodies. We can’t possibly cover everything in this post (and even if we tried, it would be outdated in a week), so just look through everything and decide what you may want to try. Each flag has details about which operating systems it works on—Chrome for Windows, Mac, or Linux; Chrome OS, or all of those. Make sure to pay attention to that.

    该地址将打开标志菜单,您将在其中找到各种新的好东西。 我们可能无法涵盖本文中的所有内容(即使我们尝试过,一周后也会过时),因此只需仔细阅读所有内容,然后决定您想尝试的内容即可。 每个标志都有有关在哪个操作系统上运行的详细信息-适用于Windows,Mac或Linux的Chrome; Chrome操作系统,或所有这些。 请务必注意这一点。

    After enabling a flag, you’ll need to restart your browser. Fortunately, a little button that helps with that will show up at the bottom of the page, making it easy to apply your new features. You can also apply several at one time, then restart when you’re done, though we recommend enabling one at a time and then testing each out. That way, it’s easier to pinpoint exactly which flag is the culprit should a problem arise.

    启用标记后,您需要重新启动浏览器。 幸运的是,页面底部将显示一个小按钮,可以帮助您轻松应用新功能。 您也可以一次应用多个,然后在完成后重新启动,尽管我们建议一次启用一个,然后进行测试。 这样,在出现问题时更容易精确地确定是哪个标志。

    变更发布渠道 (Change Release Channels)

    By default, all Chrome installations are on the stable channel—this includes browser installs on Windows, Mac, or Linux, as well as Chromebooks. And that makes sense. Google wants everyone to have the best experience possible right out of the gate.

    默认情况下,所有Chrome安装均位于稳定通道上-包括Windows,Mac或Linux上的浏览器安装以及Chromebook。 这是有道理的。 Google希望每个人都能尽享最佳体验。

    If you’re not a “stable channel” kind of person, however, you can get access to all sorts of new stuff by switching to a different release channel. Right now, there are three primary channels:

    但是,如果您不是“稳定频道”这类人,则可以通过切换到其他发行频道来访问各种新内容。 目前,共有三个主要渠道:

    • Stable: This is the default channel option. Choose this channel for rock solid dependability.

      稳定 :这是默认频道选项。 选择此通道可获得坚如磐石的可靠性。

    • Beta: Offers access to newer features that are almost ready to be included in the stable channel. The beta channel allows you to test new features before they roll out to the masses, and is still mostly stable in our experience.

      Beta:提供对更新功能的访问,这些更新功能几乎已准备好包含在稳定版中。 Beta通道可让您在新功能推出之前对其进行测试,并且在我们的经验中仍然保持稳定。

    • Developer: Designed for developers to test new features, this is the most unstable of the three release channels, but it also offers the newest features quicker than the others. Only use this channel if you don’t mind a little instability in your life.

      开发人员:专为开发人员测试新功能而设计,这是三个发行渠道中最不稳定的一个,但它也提供了比其他版本更快的最新功能。 仅当您不介意生活中有些不稳定时,才使用此频道。

    If you’re not scared away from changing channels yet, here’s how you can jump from the stable channel to something a little more rough around the edges.


    如何在Chrome操作系统上更改频道 (How to Change Channels on Chrome OS)

    First, click the “Customize” button (the one with three dots) in the upper right corner of the Chrome window, and then choose the “Settings” option.


    On the “Settings” screen, click the Main Menu button (the icon with three lines) in the top left corner, and then choose “About Chrome OS.”


    On the “About Chrome OS” screen, click the “Detailed build information” button.


    Next, click the “Change Channel” button, and then choose the channel you want.


    如何在浏览器中更改频道 (How to Change Channels in the Browser)

    Changing channels on the browser is a little more straightforward: just download the version you want and install it. Simple. Note that this will replace your existing Chrome installation. You cannot run more than one channel at the same time.

    在浏览器上更改频道更加简单:只需下载所需的版本并安装它即可。 简单。 请注意,这将替换您现有的Chrome安装。 您不能同时运行多个频道。

    You can find a full list of available downloads here—just choose your OS, build (32-bit or 64-bit), and release channel. Done and done.

    您可以在此处找到可用下载完整列表,只需选择您的操作系统,构建(32位或64位)并发布渠道即可。 做完了。

    活在流血边缘:使用金丝雀 (Live on the Bleeding Edge: Use Canary)

    If you really want to see what Google is cooking, the Canary channel is the way to go. This is an enhanced developer build of Chrome that gets nightly commits pushed into its code—this means it’s highly unstable, but is also running the absolute latest features Google is working on.

    如果您真的想看看Google在做什么,那么Canary频道就是您的不二之选。 这是Chrome的增强开发人员版本,每天晚上都会将提交提交推送到其代码中-这意味着它非常不稳定,而且还运行着Google正在开发的绝对最新功能。

    To run Canary on your PC, Mac, or Linux machine, simply download the Canary build and install it. Unlike other builds of Chrome, Canary will install as a standalone browser—meaning it won’t overwrite your existing installation. This way, you can run the stable, beta, or developer version of Chrome, and also run Canary alongside your main installation. That’s neat.

    要在您的PC,Mac或Linux计算机上运行Canary,只需下载Canary版本并安装 。 与其他版本的Chrome不同,Canary将作为独立的浏览器安装-这意味着它不会覆盖您现有的安装。 这样,您可以运行稳定版,测试版或开发者版本的Chrome,也可以在主要安装文件中同时运行Canary。 那很整齐。

    Chrome OS, on the other hand, doesn’t work that way. You can only have one installation of Chrome OS at a time, so you really have to commit to running this highly unstable version of the operating system. As a result, they don’t make it a simple transition. To switch to the Canary build of Chrome OS, you’ll first need to put your Chromebook into developer mode.

    另一方面,Chrome操作系统无法正常运行。 一次只能安装一个Chrome OS,因此您确实必须致力于运行此高度不稳定的操作系统版本。 结果,他们没有使它成为简单的过渡。 要切换到Canary版本的Chrome操作系统,您首先需要将Chromebook 置于开发人员模式

    Note: Developer Mode and the Developer Channel are two different things. Read the post linked above for more information on what developer mode is and what you can do with it.

    注意:“开发人员模式”和“开发人员通道”是两个不同的事物。 阅读上面链接的文章,以了解有关什么是开发人员模式以及可以使用该模式的更多信息。

    After entering developer mode, open a CROSH shell (Ctrl+Alt+T), type the following text, and then press Enter:

    进入开发人员模式后,打开CROSH Shell(Ctrl + Alt + T),键入以下文本,然后按Enter:


    You’ll be asked if you’re sure you want to switch. If you’re all in, type “Y” and hit Enter.

    系统将询问您是否确定要切换。 如果您全神贯注,请键入“ Y”,然后按Enter。

    Head back to Settings > About Chrome OS, and then check for updates. This should download and install the Canary build. And good luck! It’s going to be a bumpy ride from here on out.

    返回设置>关于Chrome操作系统,然后检查更新。 这应该下载并安装Canary版本。 还有祝你好运! 从现在开始,这将是一个坎bump的旅程。

    For more information on the Chrome OS Canary channel, along with how to switch back to one of the more stable builds, check out our post on switching to or leaving the Canary channel on your Chromebook.


    翻译自: https://www.howtogeek.com/179070/how-to-get-access-to-experimental-features-on-your-chromebook-or-just-in-chrome/


  • 多维高斯统计特性 随机模拟 ...A well-known market phenomenon in the futures market is that the futures prices may deviate from the spot price of the underlying asset. As shown in an earlier ar...


    随机模拟 (Stochastic Simulation)

    A well-known market phenomenon in the futures market is that the futures prices may deviate from the spot price of the underlying asset. As shown in an earlier article, the differential between futures and spot prices, called the basis, can be positive or negative, but are expected to converge to zero or near-zero at the expiration of the futures contract.

    期货市场中一个众所周知的市场现象是,期货价格可能会与基础资产的现货价格有所不同。 如前一篇文章中所示, 期货现货价格之间的差(称为基准 )可以为正或负,但在期货合约到期时,预计将收敛至零或接近零。

    For each underlying asset, there are multiple futures with different maturities (ranging from 1 month to over a year). And for each futures contract, there is one basis process. Therefore, when we consider all different spot assets and their associated futures, there are a high number of basis processes.

    对于每种基础资产,都有多个到期日不同的期货(从1个月到一年以上不等)。 对于每个期货合约,都有一个基础流程。 因此,当我们考虑所有不同的现货资产及其关联的期货时,存在大量的基础流程。

    Moreover, these stochastic processes are clearly dependent. First, the spot assets, such as silver and gold, can be (possibly highly) correlated. Second, the futures written on the same underlying asset are clearly driven by a common source of randomness, among other factors. For anyone trading futures (on the same underlying or different assets), it is crucial to understand the dependence among these processes.

    而且,这些随机过程显然是依赖的 。 首先,可以(可能是高度)关联现货资产,例如白银和黄金。 其次,写在同一基础资产上的期货显然是由共同的随机性来源以及其他因素驱动的。 对于任何交易期货(使用相同基础资产或不同资产)的人来说,了解这些流程之间的依赖性至关重要。

    多维比例布朗桥 (Multidimensional Scaled Brownian Bridge)

    This motivates us to develop a novel model to capture the joint dynamics of stochastic basis from different underlyings and different futures contracts. Once this model is built, we apply it to dynamic futures trading, as studied in this paper.

    这激励我们开发一种新颖的模型,以捕获来自不同底层证券和不同期货合约的随机基础的联合动态。 建立此模型后,我们将其应用于动态期货交易,如本文所述

    The Multidimensional Scaled Brownian Bridge (MSBB) is a continuous-time stochastic model described by the following multidimensional stochastic differential equation (SDE):


    Image for post



    Image for post
    Image for post

    and W consists of Brownian motions.


    In fact, Z is a N-dimensional process where each component is a 1-dimensional scaled Brownian bridge:

    实际上, Z是一个N维过程,其中每个分量都是一维缩放的布朗桥

    Image for post
    The stochastic differential equation for a 1-d scaled Brownian bridge. Note that the scaled Brownian bridges Zᵢ are correlated.
    一维比例布朗桥的随机微分方程。 注意,缩放的布朗桥Z 1是相关的。

    The SDE for the multidimensional scaled Brownian bridge has a unique solution


    Image for post

    Here, we used the shorthand notation for the diagonal matrix: diag (aᵢ ) = diag(a₁ , . . . , a_N).

    在这里,我们使用对角矩阵的简写形式:diag(aᵢ)= diag(a₁,。。,a_N)。

    The mean function of Z is given by


    Image for post



    Image for post
    κᵢ is the scaling parameter.

    And the covariance function is


    Image for post

    Figure 1 illustrates the simulated paths of Z , S , and F for two pairs of futures and underlying assets (i.e. N = 2). Here, each Z is the log basis (i.e. log(F/S)) for the corresponding asset and futures contract. The plots for (Zt,1) and (Zt,2) also show the 95% confidence intervals of the log-bases.

    图1说明了两对期货和基础资产(即N = 2)的ZSF的模拟路径。 在此,每个Z是相应资产和期货合约的对数基础(即log(F / S))。 (Zt,1)和(Zt,2)的图还显示了对数基准的95%置信区间。

    Image for post
    Figure 1: Simulated sample paths of S and F for two pairs of futures and spot (i.e. N = 2), and the corresponding 2-dimensional basis processes Z. Source: https://arxiv.org/pdf/1910.04943.pdf
    图1:两对期货和现货(即N = 2)的S和F的模拟样本路径,以及相应的二维基础过程Z。来源: https : //arxiv.org/pdf/1910.04943.pdf

    These plots showcase two characteristics of the log-bases. Firstly, they are mean-reverting in that any deviation from their mean is corrected. Secondly, they partially converge to zero at the end of the trading horizon (T = 0.25) as evident by narrowing of the confidence intervals. Indeed, (Zt,1) and (Zt,2) are Brownian bridges that converge to zero at T₁ = 0.27 and T₂ = 0.254, respectively. This convergence is not realized since trading stops at T = 0.25 in this particular example.

    这些图展示了对数库的两个特征。 首先,它们是均值回归 ,因为任何与均值的偏差都可以得到校正。 其次,在置信区间变窄的情况下,它们在交易期限结束时(T = 0.25)部分收敛于零。 实际上,(Zt,1)和(Zt,2)是布朗桥,它们分别在T 1 = 0.27和T 2 = 0.254处收敛到零。 由于在此特定示例中交易在T = 0.25处停止,因此无法实现这种收敛。

    Since, Zt |Z₀ is a multivariate normal random variable, this means that

    由于Zt |Z₀是多元正态随机变量,因此这意味着

    Image for post

    has chi-squared distribution with N degrees of freedom. This relationship is utilized for obtaining the 95% confidence regions of Zt represented by dashed blue ellipses. These plots also illustrate partial convergence of log-bases at the end of time horizon.

    具有N个自由度的卡方分布 。 利用该关系来获得由虚线蓝色椭圆表示的Zt的95%置信区域。 这些图还说明了时间范围结束时对数基准的部分收敛。

    Image for post
    Simulated values of (Z₁ , Z₂ ) based on 400 Simulated paths observed at three different times: t = 0.05 (left), t = 0.15 (middle), and t = 0.25(right). The dotted lines represent the border of the 95% confidence region for (Z₁, Z₂), conditional on Z₀ = (0,0). Source: https://arxiv.org/pdf/1910.04943.pdf
    (Z 1,Z 2)的模拟值基于在三个不同时间观察到的400条模拟路径:t = 0.05(左),t = 0.15(中)和t = 0.25(右)。 虚线代表(Z 1,Z 2)95%置信区的边界,条件是Z 1 =(0,0)。 资料来源: https : //arxiv.org/pdf/1910.04943.pdf

    模拟 (Simulation)

    The SDE solution for the multidimensional scaled Brownian bridge actually lends itself to a simulation algorithm. We refer to the paper for details, but the main idea is to discretize the time horizon in M time steps, simulate independent Gaussian random variables, and put them in the right places as follows:

    多维比例布朗桥的SDE解决方案实际上适用于仿真算法。 我们参考本文以获取详细信息,但是主要思想是在M个时间步中离散时间范围,模拟独立的高斯随机变量,并将其放在正确的位置,如下所示:

    Image for post
    Source: https://arxiv.org/pdf/1910.04943.pdf
    资料来源: https : //arxiv.org/pdf/1910.04943.pdf

    For any notations not explained herein, please refer to the paper below.


    外卖 (Takeaways)

    For trading systems that involve multiple futures and assets, it is imperative to properly capture the dependence among price processes. MSBB described herein is designed for modeling the joint dynamics among futures and their spot assets. Through the solution to the stochastic differential question, this model is straightforward to simulate. With simulated sample paths, one can test the performance of trading strategies.

    对于涉及多个期货和资产的交易系统,必须正确地捕捉价格过程之间的依赖关系。 本文描述的MSBB旨在模拟期货及其现货资产之间的联合动态。 通过解决随机微分问题,该模型很容易模拟。 通过模拟的样本路径,可以测试交易策略的性能。

    翻译自: https://towardsdatascience.com/multidimensional-scaled-brownian-bridge-properties-simulation-79425356f9bc


  • BIOS14:Statistic Exercise 1

    2020-02-12 03:39:39
    a) Student number 2 is a new student with little experience of elephants, and professor Elestat thus had a prior expectation that he might deviate from the others in his measurements. Does he? (4p) I ...
  • that may cause the product to deviate from published specifications. Current characterized errata are documented in the specification updates.2 Intel:registered: 64 and IA-32 Architectures Software ...



1 2 3 4 5 ... 19
收藏数 362
精华内容 144