Deprecated in favor of :meth:`.get_solvers`.
766747
def solvers(self, refresh=False, **filters):
        """"""
        warnings.warn("'solvers' is deprecated in favor of 'get_solvers'.", DeprecationWarning)
        return self.get_solvers(refresh=refresh, **filters)
130054
def _regressors(self):
        

        # sklearn version < 0.18.0
        regressors = ()

        # sklearn version >= 0.18.0
        if self.sklearn_ver[:2] >= (0, 18):
            from sklearn.neural_network.multilayer_perceptron \
                import MLPRegressor
            regressors += (MLPRegressor, )

        return regressors
965314
def filter_solvers(solvers, requirements):
    """"""
    for solver in solvers:
        for req, value in iteritems(requirements):
            if (req in ('integer', 'quadratic', 'rational', 'name') and
                    (req not in solver or solver[req] != value)):
                break
        else:
            yield solver
817249
def depsolve(self):
        """"""
        # load everything
        requires = {}
        provides = {}
        for mode, r in self.recipes.items():
            l = self.load_recipe_object(mode)

            for field, vv in l.requirements().items():
                if vv.type.isproduct():
                    name = vv.type.name()
                    pe = ProductEntry(name, mode, field)
                    requires[name] = pe

            for field, vv in l.products().items():
                if vv.type.isproduct():
                    name = vv.type.name()
                    pe = ProductEntry(name, mode, field)
                    provides[name] = pe

        return requires, provides
1199464
def dot_solve(self, y):
        

        """
        return np.dot(y.T, cho_solve(self._factor, y))
1129804
def computed(self):
        
        return (
            self._computed and
            self.solver.computed and
            (self.kernel is None or not self.kernel.dirty)
        )
413177
def resolved_packages(self):
        
        if (self.status != SolverStatus.solved):
            return None

        final_phase = self.phase_stack[-1]
        return final_phase._get_solved_variants()
505948
def get_optimization_gradients(self):
        """"""
        grad_array = self.fields.get("Opt point       1 Gradient at each geome")
        if grad_array is None:
            return []
        else:
            return np.reshape(grad_array, (-1, len(self.molecule.numbers), 3))
1336607
def solve(self, scenario, solver):
        
        clusters = set(self.clustering.busmap.values)
        n = len(clusters)
        self.stats = {'clusters': pd.DataFrame(
            index=sorted(clusters),
            columns=["decompose", "spread", "transfer"])}
        profile = cProfile.Profile()
        for i, cluster in enumerate(sorted(clusters)):
            print('---')
            print('Decompose cluster %s (%d/%d)' % (cluster, i+1, n))
            profile.enable()
            t = time.time()
            partial_network, externals = self.construct_partial_network(
                    cluster,
                    scenario)
            profile.disable()
            self.stats['clusters'].loc[cluster, 'decompose'] = time.time() - t
            print('Decomposed in ',
                  self.stats['clusters'].loc[cluster, 'decompose'])
            t = time.time()
            profile.enable()
            self.solve_partial_network(cluster, partial_network, scenario,
                                       solver)
            profile.disable()
            self.stats['clusters'].loc[cluster, 'spread'] = time.time() - t
            print('Result distributed in ',
                  self.stats['clusters'].loc[cluster, 'spread'])
            profile.enable()
            t = time.time()
            self.transfer_results(partial_network, externals)
            profile.disable()
            self.stats['clusters'].loc[cluster, 'transfer'] = time.time() - t
            print('Results transferred in ',
                  self.stats['clusters'].loc[cluster, 'transfer'])

        profile.enable()
        t = time.time()
        print('---')
        fs = (mc("sum"), mc("sum"))
        for bt, ts in (
                ('generators', {'p': fs, 'q': fs}),
                ('storage_units', {'p': fs, 'state_of_charge': fs, 'q': fs})):
            print("Attribute sums, {}, clustered - disaggregated:" .format(bt))
            cnb = getattr(self.clustered_network, bt)
            onb = getattr(self.original_network, bt)
            print("{:>{}}: {}".format('p_nom_opt', 4 + len('state_of_charge'),
                reduce(lambda x, f: f(x), fs[:-1], cnb['p_nom_opt'])
                    -
                    reduce(lambda x, f: f(x), fs[:-1], onb['p_nom_opt'])))

            print("Series sums, {}, clustered - disaggregated:" .format(bt))
            cnb = getattr(self.clustered_network, bt + '_t')
            onb = getattr(self.original_network, bt + '_t')
            for s in ts:
                print("{:>{}}: {}".format(s, 4 + len('state_of_charge'),
                    reduce(lambda x, f: f(x), ts[s], cnb[s])
                    -
                    reduce(lambda x, f: f(x), ts[s], onb[s])))
        profile.disable()
        self.stats['check'] = time.time() - t
        print('Checks computed in ', self.stats['check'])
298547
def check_solver(self, kwargs_lens, kwargs_ps, kwargs_cosmo={}):
        
        if self._solver is True:
            image_x, image_y = kwargs_ps[0]['ra_image'], kwargs_ps[0]['dec_image']
            image_x, image_y = self.real_image_positions(image_x, image_y, kwargs_cosmo)
            dist = self._solver_module.check_solver(image_x, image_y, kwargs_lens)
            return np.max(dist)
        else:
            return 0
667213
def solve(self, S, W=None, dimK=None):
        """"""

        # Use dimK specified in __init__ as default
        if dimK is None and self.dimK is not None:
            dimK = self.dimK

        # Start solve timer
        self.timer.start(['solve', 'solve_wo_eval'])

        # Solve CSC problem on S and do dictionary step
        self.init_vars(S, dimK)
        if W is None:
            W = np.array([1.0], dtype=self.dtype)
        W = np.asarray(W.reshape(cr.mskWshape(W, self.cri)),
                       dtype=self.dtype)
        self.xstep(S, W, self.lmbda, dimK)
        self.dstep(W)

        # Stop solve timer
        self.timer.stop('solve_wo_eval')

        # Extract and record iteration stats
        self.manage_itstat()

        # Increment iteration count
        self.j += 1

        # Stop solve timer
        self.timer.stop('solve')

        # Return current dictionary
        return self.getdict()
399161
def get_vectors(self, indices=None):
        ''''''
        H_ = self._deflated_solver.H
        (n_, n) = H_.shape
        coeffs = self.coeffs if indices is None else self.coeffs[:, indices]
        return numpy.c_[self._deflated_solver.V[:, :n],
                        self._deflated_solver.projection.U].dot(coeffs)
1191141
def results
      Solve
        .it!(@graph, initial_solve_constraints)
        .map do |name, version|
          dep = @resolver.dependencies[name]
          dep.version = Semverse::Version.new(version)
          dep
        end
    end
182742
def solve_resolve(expr, vars):
    
    objs, _ = __solve_for_repeated(expr.lhs, vars)
    member = solve(expr.rhs, vars).value

    try:
        results = [structured.resolve(o, member)
                   for o in repeated.getvalues(objs)]
    except (KeyError, AttributeError):
        # Raise a better exception for the non-existent member.
        raise errors.EfilterKeyError(root=expr.rhs, key=member,
                                     query=expr.source)
    except (TypeError, ValueError):
        # Is this a null object error?
        if vars.locals is None:
            raise errors.EfilterNoneError(
                root=expr, query=expr.source,
                message="Cannot resolve member %r from a null." % member)
        else:
            raise
    except NotImplementedError:
        raise errors.EfilterError(
            root=expr, query=expr.source,
            message="Cannot resolve members from a non-structured value.")

    return Result(repeated.meld(*results), ())
84612
def se(self):
        
        global _complained_se
        if not _complained_se:
            _complained_se = True
            l.critical("The name state.se is deprecated; please use state.solver.")
        return self.get_plugin('solver')
767862
def solve(self):
        
        for i in range(4):
            for slot in ["FR", "RB", "BL", "LF"]:
                solver = F2LPairSolver(self.cube, slot)
                if not solver.is_solved():
                    yield tuple([self.cube[slot[i]].colour for i in range(2)]), solver.solve()
                    break
810744
private List<Double> knnDistances(S solution, L solutionList) {
    List<Double> listOfDistances = new ArrayList<>() ;
    for (int i = 0 ; i< solutionList.size(); i++) {
      double distanceBetweenSolutions = distance.getDistance(solution, solutionList.get(i)) ;
      if (distanceBetweenSolutions != 0) {
        listOfDistances.add(distanceBetweenSolutions) ;
      }
    }

    return listOfDistances ;
  }