Returns the statistics for this formula factory.
@return the statistics for this formula factory
493398
public FormulaFactoryStatistics statistics() {
    final FormulaFactoryStatistics statistics = new FormulaFactoryStatistics();
    statistics.name = this.name;
    statistics.positiveLiterals = this.posLiterals.size();
    statistics.negativeLiterals = this.negLiterals.size();
    statistics.negations = this.nots.size();
    statistics.implications = this.implications.size();
    statistics.equivalences = this.equivalences.size();
    statistics.conjunctions2 = this.ands2.size();
    statistics.conjunctions3 = this.ands3.size();
    statistics.conjunctions4 = this.ands4.size();
    statistics.conjunctionsN = this.andsN.size();
    statistics.disjunctions2 = this.ors2.size();
    statistics.disjunctions3 = this.ors3.size();
    statistics.disjunctions4 = this.ors4.size();
    statistics.disjunctionsN = this.orsN.size();
    statistics.pbcs = this.pbConstraints.size();
    statistics.ccCounter = this.ccCounter;
    statistics.pbCounter = this.pbCounter;
    statistics.cnfCounter = this.cnfCounter;
    return statistics;
  }
113274
public Map<String, ActiveMQQueueStats> getQueueStats() {
        Map<String, ActiveMQQueueStats> result;

        result = new TreeMap<>();

        synchronized ( this.queueStats ) {
            for (QueueStatisticsCollection queueStatisticsCollection : this.queueStats.values()) {
                result.put(queueStatisticsCollection.getQueueName(), queueStatisticsCollection.getQueueTotalStats());
            }
        }

        return result;
    }
1042547
def stats(self):
        
        out = []
        out += [("Ontologies", len(self.all_ontologies))]
        out += [("Triples", self.triplesCount())]
        out += [("Classes", len(self.all_classes))]
        out += [("Properties", len(self.all_properties))]
        out += [("Annotation Properties", len(self.all_properties_annotation))]
        out += [("Object Properties", len(self.all_properties_object))]
        out += [("Datatype Properties", len(self.all_properties_datatype))]
        out += [("Skos Concepts", len(self.all_skos_concepts))]
        out += [("Data Shapes", len(self.all_shapes))]
        # out += [("Individuals", len(self.individuals))] @TODO
        out += [("Data Sources", len(self.sources))]
        return out
279501
public String getStatistics() {
        StringBuilder sb = new StringBuilder();
        
        for(String key : stats.keySet()) {
            sb.append(key);
            sb.append(": ");
            sb.append(stats.get(key));
            sb.append("\n");
        }
        
        return sb.toString();
    }
1272172
@Override
    public String[] getAllCacheStatistics() {
        DCache cache = null;
        if (ServerCache.servletCacheEnabled) {
            cache = ServerCache.cache;
        }
        String stats[] = null;
        if (cache != null) {
            Map statistics = getCacheStatisticsMap(cache.getCacheStatistics());
            Iterator keys = statistics.keySet().iterator();
            Iterator values = statistics.values().iterator();
            stats = new String[statistics.size()];
            int i = 0;
            while (keys.hasNext()) {
                stats[i] = keys.next() + "=" + values.next();
                i++;
            }
        } else {
            stats = new String[0];
            // DYNA1059W=DYNA1059W: WebSphere Dynamic Cache instance named {0} cannot be used because of Dynamic Servlet cache service has not be started.
            Tr.error(tc, "DYNA1059W", new Object[] { DCacheBase.DEFAULT_CACHE_NAME });
        }

        return stats;
    }
754383
public Vec[] getColumnMeanVariance()
    {
        final int d = getNumNumericalVars();
        Vec[] vecs = new Vec[] 
        {
            new DenseVector(d),
            new DenseVector(d)
        };
        
        Vec means = vecs[0];
        Vec stdDevs = vecs[1];
        
        MatrixStatistics.meanVector(means, this);
        MatrixStatistics.covarianceDiag(means, stdDevs, this);
        
        return vecs;
    }
463439
public SingleRunnerStatistics getStatistics() {
        if (rp != null) {
            Measures m = rp.getSolver().getMeasures();
            stats.setMetrics(new Metrics(m));
          stats.setCompleted(m.getSearchState().equals(SearchState.TERMINATED)
                  || m.getSearchState().equals(SearchState.NEW)
          );
        }
        return stats;
    }
838260
public StatisticImpl[] getJ2EEStatistics() {
        ArrayList members = copyStatistics();
        if (members == null || members.size() == 0)
            return new StatisticImpl[0];

        StatisticImpl[] ret = new StatisticImpl[members.size()];
        for (int i = 0; i < ret.length; i++) {
            ret[i] = (StatisticImpl) members.get(i);
        }
        return ret;
    }
92827
public GetInstanceMetricDataRequest withStatistics(MetricStatistic... statistics) {
        java.util.ArrayList<String> statisticsCopy = new java.util.ArrayList<String>(statistics.length);
        for (MetricStatistic value : statistics) {
            statisticsCopy.add(value.toString());
        }
        if (getStatistics() == null) {
            setStatistics(statisticsCopy);
        } else {
            getStatistics().addAll(statisticsCopy);
        }
        return this;
    }
930371
protected function getStatistics() {
        if (!$this->_statistics) {
            $this->_statistics = new TaskQueueStatisticsList(
                $this->version,
                $this->solution['workspaceSid'],
                $this->solution['sid']
            );
        }

        return $this->_statistics;
    }
289175
public final AbstractMeter[] getMeters() {
        final AbstractMeter[] returnVal = new AbstractMeter[meters.length];
        System.arraycopy(meters, 0, returnVal, 0, returnVal.length);
        return returnVal;
    }
728709
public String stats() {
        ICURWLock.Stats stats = factoryLock.resetStats();
        if (stats != null) {
            return stats.toString();
        }
        return "no stats";
    }
124170
public static synchronized ExecutionStatistics get()
    {
        Thread currentThread = Thread.currentThread();
        if (stats.get(currentThread) == null)
        {
            stats.put(currentThread, new ExecutionStatistics());
        }
        return stats.get(currentThread);
    }
563051
public java.util.List<MetricDataResult> getMetricDataResults() {
        if (metricDataResults == null) {
            metricDataResults = new com.amazonaws.internal.SdkInternalList<MetricDataResult>();
        }
        return metricDataResults;
    }
135455
public Optional<CacheStatistics> getStatistics(String cacheName) {

        javax.cache.Cache cache = cacheManager.getCache(cacheName);

        if (cache == null) {
            return Optional.empty();
        }

        if (((CompleteConfiguration) cache.getConfiguration(CompleteConfiguration.class)).isStatisticsEnabled() && cache instanceof ICache) {
            com.hazelcast.cache.CacheStatistics stats = ((ICache) cache).getLocalCacheStatistics();
            CacheStatistics statistics = new CacheStatistics(
                    stats.getCacheHits(),
                    stats.getCacheMisses(),
                    stats.getCacheHitPercentage(),
                    stats.getCacheMissPercentage(),
                    stats.getCacheGets(),
                    stats.getCachePuts(),
                    stats.getCacheRemovals(),
                    stats.getCacheEvictions(),
                    stats.getAverageGetTime(),
                    stats.getAveragePutTime(),
                    stats.getAverageRemoveTime());

            return Optional.of(statistics);
        }

        return Optional.empty();
    }
325466
public Map<Integer, ClientAffinityStats> getAffinityStats()
    {
        Map<Integer, ClientAffinityStats> retval = new TreeMap<Integer, ClientAffinityStats>();
        for (Entry<Integer, ClientAffinityStats> e : m_currentAffinity.entrySet()) {
            if (m_baselineAffinity.containsKey(e.getKey())) {
                retval.put(e.getKey(), ClientAffinityStats.diff(e.getValue(), m_baselineAffinity.get(e.getKey())));
            }
            else {
                retval.put(e.getKey(), (ClientAffinityStats) e.getValue().clone());
            }
        }
        return retval;
    }
570863
def statistics(self):
        
        result = {}
        for r in self.results:
            result.setdefault(r.status, 0)
            result[r.status] += 1
        return result