dot-atom        =   [CFWS] dot-atom-text [CFWS]
14819
function dotAtom() {
        return wrap('dot-atom', and(invis(opt(cfws)), dotAtomText, invis(opt(cfws)))());
    }
256415
def get_cfws(value):
    
    cfws = CFWSList()
    while value and value[0] in CFWS_LEADER:
        if value[0] in WSP:
            token, value = get_fws(value)
        else:
            token, value = get_comment(value)
        cfws.append(token)
    return cfws, value
171234
function (text, sep) {
/*Line 27 - 'WebAtoms.Core.js' */        if (sep && sep.constructor == String) {
/*Line 28 - 'WebAtoms.Core.js' */            sep = $.trim(sep);
/*Line 29 - 'WebAtoms.Core.js' */        }
/*Line 30 - 'WebAtoms.Core.js' */        var ar = text.split(sep);
/*Line 31 - 'WebAtoms.Core.js' */        var r = [];
/*Line 32 - 'WebAtoms.Core.js' */        var ae = new AtomEnumerator(ar);
/*Line 33 - 'WebAtoms.Core.js' */        var item;
/*Line 34 - 'WebAtoms.Core.js' */        while (ae.next()) {
/*Line 35 - 'WebAtoms.Core.js' */            item = ae.current();
/*Line 36 - 'WebAtoms.Core.js' */            if (item && item.constructor == String) {
/*Line 37 - 'WebAtoms.Core.js' */                item = $.trim(item);
/*Line 38 - 'WebAtoms.Core.js' */            }
/*Line 39 - 'WebAtoms.Core.js' */            r.push(item);
/*Line 40 - 'WebAtoms.Core.js' */        }
/*Line 41 - 'WebAtoms.Core.js' */        return r;
/*Line 42 - 'WebAtoms.Core.js' */    }
728774
def write_dot(build_context, conf: Config, out_f):
    """"""
    not_buildenv_targets = get_not_buildenv_targets(build_context)
    prebuilt_targets = get_prebuilt_targets(build_context)
    out_f.write('strict digraph  {\n')
    for node in build_context.target_graph.nodes:
        if conf.show_buildenv_deps or node in not_buildenv_targets:
            cached = node in prebuilt_targets
            fillcolor = 'fillcolor="grey",style=filled' if cached else ''
            color = TARGETS_COLORS.get(
                build_context.targets[node].builder_name, 'black')
            out_f.write('  "{}" [color="{}",{}];\n'.format(node, color,
                                                           fillcolor))
    out_f.writelines('  "{}" -> "{}";\n'.format(u, v)
                     for u, v in build_context.target_graph.edges
                     if conf.show_buildenv_deps or
                     (u in not_buildenv_targets and v in not_buildenv_targets))
    out_f.write('}\n\n')
1243715
def to_dot(buffer='')
      buffer << "digraph G {\n"
      buffer << "  graph[#{to_dot_attributes(self.to_h(true))}]\n"
      each_vertex do |v|
        buffer << "  V#{v.index} [#{to_dot_attributes(v.to_h(true))}]\n"
      end
      each_edge do |e|
        buffer << "  V#{e.source.index} -> V#{e.target.index} [#{to_dot_attributes(e.to_h(true))}]\n"
      end
      buffer << "}\n"
    end
904377
function cfws() {
        return wrap('cfws', or(
            and(
                star(
                    and(opt(fws), comment),
                    1
                ),
                opt(fws)
            ),
            fws
        )());
    }
448986
def dot(matrix, vector):
    
    matrix_weld_type = None
    vector_weld_type = None

    if isinstance(matrix, LazyOpResult):
        matrix_weld_type = matrix.weld_type
        matrix = matrix.expr
    elif isinstance(matrix, np.ndarray):
        matrix_weld_type = numpy_weld_impl.numpy_to_weld_type_mapping[
            str(matrix.dtype)]

    if isinstance(vector, LazyOpResult):
        vector_weld_type = vector.weld_type
        vector = vector.expr
    elif isinstance(vector, np.ndarray):
        vector_weld_type = numpy_weld_impl.numpy_to_weld_type_mapping[
            str(vector.dtype)]

    return NumpyArrayWeld(
        numpy_weld_impl.dot(
            matrix,
            vector,
            matrix_weld_type,
            vector_weld_type),
        WeldDouble())
1147017
function generateCFIs(cfiBase, elements, needOffset) {

    const cfiList = [];

    for (const key in elements) {

        const cfiParts = [];

        const textNode = elements[key].textNode;
        var child = textNode.parent();
        const childContents = child.contents();


        var textNodeIndex = childContents.index(textNode) + 1;

        // "mixed content" context
        // the first chunk is located before the first child element
        // <p><span></span>text</p>
        if (childContents.first()[0].type === "tag") {
            textNodeIndex += 1;
        }

        var parent = child.parent();
        while (parent[0]) {
            const index = child.index(),
                inOff = (needOffset && parent[0].name === 'body'),
                id = child.attr('id'),
                idSelector = id ? '[' + id + ']' : '',
                part = ((index + 1) * 2 + (inOff ? 2 : 0)) + idSelector;

            cfiParts.unshift(part);

            child = parent;
            parent = child.parent();
        }
        const startOffset = elements[key].range.startOffset,
            endOffset = elements[key].range.endOffset;

        const inlinePath = ',/' + textNodeIndex + ':';
        const cfi = cfiBase + '/' + cfiParts.join('/') + inlinePath + startOffset + inlinePath + endOffset;

        cfiList.push({ cfi, excerpt: elements[key].excerpt });
    }
    return cfiList;
}
1130910
def from_file(xmu_dat_file="xmu.dat", feff_inp_file="feff.inp"):
        
        data = np.loadtxt(xmu_dat_file)
        header = Header.from_file(feff_inp_file)
        parameters = Tags.from_file(feff_inp_file)
        pots = Potential.pot_string_from_file(feff_inp_file)
        # site index (Note: in feff it starts from 1)
        if "RECIPROCAL" in parameters:
            absorbing_atom = parameters["TARGET"]
        # species symbol
        else:
            absorbing_atom = pots.splitlines()[3].split()[2]
        return Xmu(header, parameters, absorbing_atom, data)
411891
function (match) {
    var temp = match[0], result;

    function checkDot(ctx) {
      var c = ctx + temp,
        m = match,
        build = '';

      build = '(typeof ' + c + ' !== "undefined" && ' + c + ' !== null';
      utils.each(m, function (v, i) {
        if (i === 0) {
          return;
        }
        build += ' && ' + c + '.' + v + ' !== undefined && ' + c + '.' + v + ' !== null';
        c += '.' + v;
      });
      build += ')';

      return build;
    }

    function buildDot(ctx) {
      return '(' + checkDot(ctx) + ' ? ' + ctx + match.join('.') + ' : "")';
    }
    result = '(' + checkDot('_ctx.') + ' ? ' + buildDot('_ctx.') + ' : ' + buildDot('') + ')';
    return '(' + result + ' !== null ? ' + result + ' : ' + '"" )';
  }
723070
def dot(*values: Union[float, complex, np.ndarray]
        ) -> Union[float, complex, np.ndarray]:
    
    if len(values) == 1:
        if isinstance(values[0], np.ndarray):
            return np.array(values[0])
        return values[0]
    return np.linalg.multi_dot(values)
1125162
def get_local_part(value):
    
    local_part = LocalPart()
    leader = None
    if value[0] in CFWS_LEADER:
        leader, value = get_cfws(value)
    if not value:
        raise errors.HeaderParseError(
            "expected local-part but found '{}'".format(value))
    try:
        token, value = get_dot_atom(value)
    except errors.HeaderParseError:
        try:
            token, value = get_word(value)
        except errors.HeaderParseError:
            if value[0] != '\\' and value[0] in PHRASE_ENDS:
                raise
            token = TokenList()
    if leader is not None:
        token[:0] = [leader]
    local_part.append(token)
    if value and (value[0]=='\\' or value[0] not in PHRASE_ENDS):
        obs_local_part, value = get_obs_local_part(str(local_part) + value)
        if obs_local_part.token_type == 'invalid-obs-local-part':
            local_part.defects.append(errors.InvalidHeaderDefect(
                "local-part is not dot-atom, quoted-string, or obs-local-part"))
        else:
            local_part.defects.append(errors.ObsoleteHeaderDefect(
                "local-part is not a dot-atom (contains CFWS)"))
        local_part[0] = obs_local_part
    try:
        local_part.value.encode('ascii')
    except UnicodeEncodeError:
        local_part.defects.append(errors.NonASCIILocalPartDefect(
                "local-part contains non-ASCII characters)"))
    return local_part, value
1153425
def convert_dot(node, **kwargs):
    """"""
    name, input_nodes, attrs = get_inputs(node, kwargs)
    input_node_a = input_nodes[0]
    input_node_b = input_nodes[1]

    trans_a_node = None
    trans_b_node = None

    trans_a = get_boolean_attribute_value(attrs, "transpose_a")
    trans_b = get_boolean_attribute_value(attrs, "transpose_b")

    op_name = "transpose" + str(kwargs["idx"])

    if trans_a:
        trans_a_node = create_helper_trans_node(op_name, input_nodes[0], 'a')
        input_node_a = op_name+"_a"
    if trans_b:
        trans_b_node = create_helper_trans_node(op_name, input_nodes[1], 'b')
        input_node_b = op_name+"_b"

    matmul_node = onnx.helper.make_node(
        'MatMul',
        inputs=[input_node_a, input_node_b],
        outputs=[name],
        name=name
    )

    if not trans_a and not trans_b:
        return [matmul_node]
    elif trans_a and not trans_b:
        return [trans_a_node, matmul_node]
    elif trans_b and not trans_a:
        return [trans_b_node, matmul_node]
    else:
        return [trans_a_node, trans_b_node, matmul_node]
42774
def write_atoms(fn, this, cycfn=None, conv=1.0, symbols=True):
    
    f = paropen(fn, "w")

    f.write("<--- Number of atoms\n")
    f.write("%i\n" % len(this))
    f.write("<--- Number of occupied orbitals\n")
    f.write("%f\n" % 0.0)
    f.write("<--- Atom positions\n")

    groups = None
    if this.has("groups"):
        groups = this.get_array("groups")

    gamma = None
    if this.has("gamma"):
        gamma = this.get_array("gamma")

    T = None
    if this.has("T"):
        T = this.get_array("T")

    for idx, i in enumerate(this):
        group_str = "1"
        if groups is not None:
            group_str = "%i" % groups[idx]
        gamma_str = "0.0"
        if gamma is not None:
            gamma_str = "%20.10e" % gamma[idx]
        T_str = "0.0"
        if T is not None:
            T_str = "%20.10e" % T[idx]

        sym = i.symbol

        r = i.position

        if symbols:
            f.write("%s   %f   %20.10e  %20.10e  %20.10e   %s %s %s\n" % (sym, ase.data.atomic_masses[ase.data.chemical_symbols.index(sym)], r[0]*conv, r[1]*conv, r[2]*conv, group_str, gamma_str, T_str))
        else:
            f.write("%i   %f   %20.10e  %20.10e  %20.10e   %s %s %s\n" % (ase.data.chemical_symbols.index(sym), ase.data.atomic_masses[ase.data.chemical_symbols.index(sym)], r[0]*conv, r[1]*conv, r[2]*conv, group_str, gamma_str, T_str))


    f.write("<--- Velocities\n")
    for i in this:
        m = i.mass
        if m is None:
            m = ase.data.atomic_masses[ase.data.chemical_symbols.index(i.symbol)]
        if i.momentum is not None:
            v = i.momentum/m
        else:
            v = [ 0.0, 0.0, 0.0 ]
        f.write("%20.10e %20.10e %20.10e\n" % ( v[0], v[1], v[2] ))

    f.write("<--- Forces\n")
    for i in this:
        f.write("0 0 0\n")

    f.write("<--- cell\n")
    cell = this.get_cell()
    f.write("%f %f %f\n" % tuple(cell[0, :]))
    f.write("%f %f %f\n" % tuple(cell[1, :]))
    f.write("%f %f %f\n" % tuple(cell[2, :]))

    for name, aux in this.arrays.items():
        if not name in atoms_default_fields:
            f.write("<--- %s\n" % name)
            if aux.dtype == int:
                if len(aux.shape) == 1:
                    for i in this:
                        f.write(" %i\n" % aux[i.index])
                else:
                    for i in this:
                        f.write(( aux.shape[1]*" %i" + "\n" ) % tuple(aux[i.index].tolist()))
            else:
                if len(aux.shape) == 1:
                    for i in this:
                        f.write(" %e\n" % aux[i.index])
                else:
                    for i in this:
                        f.write(( aux.shape[1]*" %e" + "\n" ) % tuple(aux[i.index].tolist()))

    f.close()

    if cycfn:
        write_cyc(cycfn, this, conv=conv)
914693
def p_formula_atom(self, p):
        """"""
        if p[1]==Symbols.TRUE.value:
            p[0] = PLTrue()
        elif p[1]==Symbols.FALSE.value:
            p[0] = PLFalse()
        else:
            p[0] = PLAtomic(Symbol(p[1]))
827986
def dot(self, vec):
        """"""

        return self.x * vec.x + self.y * vec.y
5914
def ctcp(self, target, ctcp_verb, argument=None):
        """"""
        # we don't support complex ctcp encapsulation because we're somewhat sane
        atoms = [ctcp_verb]
        if argument is not None:
            atoms.append(argument)
        X_DELIM = '\x01'
        self.msg(target, X_DELIM + ' '.join(atoms) + X_DELIM, formatted=False)