Compute the continuous Jacard similarity between all pairs
        of keys in dictionary-of-dictionaries given as an input.

        Returns three element tuple:
            - similarity dictionary: (key, key) -> float
            - overlap count dictionary: key -> key -> int
            - weight dictionary: key -> key -> float

def jacard_similarity_from_nested_dicts(self, nested_dictionaries):
        """
        Compute the continuous Jacard similarity between all pairs
        of keys in dictionary-of-dictionaries given as an input.

        Returns three element tuple:
            - similarity dictionary: (key, key) -> float
            - overlap count dictionary: key -> key -> int
            - weight dictionary: key -> key -> float
        """
        sims = {}
        overlaps = {}
        weights = {}
        for a, column_dict_a in nested_dictionaries.items():
            row_set_a = set(column_dict_a.keys())
            for b, column_dict_b in nested_dictionaries.items():
                row_set_b = set(column_dict_b.keys())
                common_rows = row_set_a.intersection(row_set_b)
                n_overlap = len(common_rows)
                overlaps[(a, b)] = n_overlap
                total = 0.0
                weight = 0.0
                for row_name in common_rows:
                    value_a = column_dict_a[row_name]
                    value_b = column_dict_b[row_name]
                    minval = min(value_a, value_b)
                    maxval = max(value_a, value_b)
                    total += minval
                    weight += maxval
                weights[(a, b)] = weight
                if weight < self.min_weight_for_similarity:
                    continue
                if n_overlap < self.min_count_for_similarity:
                    continue
                sims[(a, b)] = total / weight
        return sims, overlaps, weights