Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/travisz09/analytical-hierarchy-process-calculator-app

Analytical Hierarchy Process app for Multi Criterion Decision Making
https://github.com/travisz09/analytical-hierarchy-process-calculator-app

analytical-hierarchy-process geographical-information-system gis multi-criteria-decision-making r shiny-apps suitability-analysis suitability-modeling weights-of-evidence

Last synced: about 2 months ago
JSON representation

Analytical Hierarchy Process app for Multi Criterion Decision Making

Awesome Lists containing this project

README 

        



readme



code{white-space: pre-wrap;}

span.smallcaps{font-variant: small-caps;}

div.columns{display: flex; gap: min(4vw, 1.5em);}

div.column{flex: auto; overflow-x: auto;}

div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}

ul.task-list{list-style: none;}

ul.task-list li input[type="checkbox"] {

  width: 0.8em;

  margin: 0 0.8em 0.2em -1em; /* quarto-specific, see https://github.com/quarto-dev/quarto-cli/issues/4556 */ 

  vertical-align: middle;

}






AHP app



Analytical Hierarchy Process app for Multi Criterion Decision Making


Calculate weights matrix for multi-criterion decision making using the analytical hierarchy process.


Input two or more component variables influencing your decision making. Adjust the pair wise comparison sliders in the direction of the more important variable, using Saaty’s absolute numbers as a reference. Based on user input a balanced weights matrix will be generated, quantifying the absolute importance of all component variables. These weights can be incorporated into a mathematical formula for decision making, especially for GIS based suitability analysis, or other matrix-based equations.



window.document.addEventListener("DOMContentLoaded", function (event) {

  const toggleBodyColorMode = (bsSheetEl) => {

    const mode = bsSheetEl.getAttribute("data-mode");

    const bodyEl = window.document.querySelector("body");

    if (mode === "dark") {

      bodyEl.classList.add("quarto-dark");

      bodyEl.classList.remove("quarto-light");

    } else {

      bodyEl.classList.add("quarto-light");

      bodyEl.classList.remove("quarto-dark");

    }

  }

  const toggleBodyColorPrimary = () => {

    const bsSheetEl = window.document.querySelector("link#quarto-bootstrap");

    if (bsSheetEl) {

      toggleBodyColorMode(bsSheetEl);

    }

  }

  toggleBodyColorPrimary();  

  const icon = "";

  const anchorJS = new window.AnchorJS();

  anchorJS.options = {

    placement: 'right',

    icon: icon

  };

  anchorJS.add('.anchored');

  const isCodeAnnotation = (el) => {

    for (const clz of el.classList) {

      if (clz.startsWith('code-annotation-')) {                     

        return true;

      }

    }

    return false;

  }

  const onCopySuccess = function(e) {

    // button target

    const button = e.trigger;

    // don't keep focus

    button.blur();

    // flash "checked"

    button.classList.add('code-copy-button-checked');

    var currentTitle = button.getAttribute("title");

    button.setAttribute("title", "Copied!");

    let tooltip;

    if (window.bootstrap) {

      button.setAttribute("data-bs-toggle", "tooltip");

      button.setAttribute("data-bs-placement", "left");

      button.setAttribute("data-bs-title", "Copied!");

      tooltip = new bootstrap.Tooltip(button, 

        { trigger: "manual", 

          customClass: "code-copy-button-tooltip",

          offset: [0, -8]});

      tooltip.show();    

    }

    setTimeout(function() {

      if (tooltip) {

        tooltip.hide();

        button.removeAttribute("data-bs-title");

        button.removeAttribute("data-bs-toggle");

        button.removeAttribute("data-bs-placement");

      }

      button.setAttribute("title", currentTitle);

      button.classList.remove('code-copy-button-checked');

    }, 1000);

    // clear code selection

    e.clearSelection();

  }

  const getTextToCopy = function(trigger) {

      const codeEl = trigger.previousElementSibling.cloneNode(true);

      for (const childEl of codeEl.children) {

        if (isCodeAnnotation(childEl)) {

          childEl.remove();

        }

      }

      return codeEl.innerText;

  }

  const clipboard = new window.ClipboardJS('.code-copy-button:not([data-in-quarto-modal])', {

    text: getTextToCopy

  });

  clipboard.on('success', onCopySuccess);

  if (window.document.getElementById('quarto-embedded-source-code-modal')) {

    // For code content inside modals, clipBoardJS needs to be initialized with a container option

    // TODO: Check when it could be a function (https://github.com/zenorocha/clipboard.js/issues/860)

    const clipboardModal = new window.ClipboardJS('.code-copy-button[data-in-quarto-modal]', {

      text: getTextToCopy,

      container: window.document.getElementById('quarto-embedded-source-code-modal')

    });

    clipboardModal.on('success', onCopySuccess);

  }

    var localhostRegex = new RegExp(/^(?:http|https):\/\/localhost\:?[0-9]*\//);

    var mailtoRegex = new RegExp(/^mailto:/);

      var filterRegex = new RegExp('/' + window.location.host + '/');

    var isInternal = (href) => {

        return filterRegex.test(href) || localhostRegex.test(href) || mailtoRegex.test(href);

    }

    // Inspect non-navigation links and adorn them if external

 	var links = window.document.querySelectorAll('a[href]:not(.nav-link):not(.navbar-brand):not(.toc-action):not(.sidebar-link):not(.sidebar-item-toggle):not(.pagination-link):not(.no-external):not([aria-hidden]):not(.dropdown-item):not(.quarto-navigation-tool):not(.about-link)');

    for (var i=0; i<links.length; i++) {

      const link = links[i];

      if (!isInternal(link.href)) {

        // undo the damage that might have been done by quarto-nav.js in the case of

        // links that we want to consider external

        if (link.dataset.originalHref !== undefined) {

          link.href = link.dataset.originalHref;

        }

      }

    }

  function tippyHover(el, contentFn, onTriggerFn, onUntriggerFn) {

    const config = {

      allowHTML: true,

      maxWidth: 500,

      delay: 100,

      arrow: false,

      appendTo: function(el) {

          return el.parentElement;

      },

      interactive: true,

      interactiveBorder: 10,

      theme: 'quarto',

      placement: 'bottom-start',

    };

    if (contentFn) {

      config.content = contentFn;

    }

    if (onTriggerFn) {

      config.onTrigger = onTriggerFn;

    }

    if (onUntriggerFn) {

      config.onUntrigger = onUntriggerFn;

    }

    window.tippy(el, config); 

  }

  const noterefs = window.document.querySelectorAll('a[role="doc-noteref"]');

  for (var i=0; i<noterefs.length; i++) {

    const ref = noterefs[i];

    tippyHover(ref, function() {

      // use id or data attribute instead here

      let href = ref.getAttribute('data-footnote-href') || ref.getAttribute('href');

      try { href = new URL(href).hash; } catch {}

      const id = href.replace(/^#\/?/, "");

      const note = window.document.getElementById(id);

      if (note) {

        return note.innerHTML;

      } else {

        return "";

      }

    });

  }

  const xrefs = window.document.querySelectorAll('a.quarto-xref');

  const processXRef = (id, note) => {

    // Strip column container classes

    const stripColumnClz = (el) => {

      el.classList.remove("page-full", "page-columns");

      if (el.children) {

        for (const child of el.children) {

          stripColumnClz(child);

        }

      }

    }

    stripColumnClz(note)

    if (id === null || id.startsWith('sec-')) {

      // Special case sections, only their first couple elements

      const container = document.createElement("div");

      if (note.children && note.children.length > 2) {

        container.appendChild(note.children[0].cloneNode(true));

        for (let i = 1; i < note.children.length; i++) {

          const child = note.children[i];

          if (child.tagName === "P" && child.innerText === "") {

            continue;

          } else {

            container.appendChild(child.cloneNode(true));

            break;

          }

        }

        if (window.Quarto?.typesetMath) {

          window.Quarto.typesetMath(container);

        }

        return container.innerHTML

      } else {

        if (window.Quarto?.typesetMath) {

          window.Quarto.typesetMath(note);

        }

        return note.innerHTML;

      }

    } else {

      // Remove any anchor links if they are present

      const anchorLink = note.querySelector('a.anchorjs-link');

      if (anchorLink) {

        anchorLink.remove();

      }

      if (window.Quarto?.typesetMath) {

        window.Quarto.typesetMath(note);

      }

      // TODO in 1.5, we should make sure this works without a callout special case

      if (note.classList.contains("callout")) {

        return note.outerHTML;

      } else {

        return note.innerHTML;

      }

    }

  }

  for (var i=0; i<xrefs.length; i++) {

    const xref = xrefs[i];

    tippyHover(xref, undefined, function(instance) {

      instance.disable();

      let url = xref.getAttribute('href');

      let hash = undefined; 

      if (url.startsWith('#')) {

        hash = url;

      } else {

        try { hash = new URL(url).hash; } catch {}

      }

      if (hash) {

        const id = hash.replace(/^#\/?/, "");

        const note = window.document.getElementById(id);

        if (note !== null) {

          try {

            const html = processXRef(id, note.cloneNode(true));

            instance.setContent(html);

          } finally {

            instance.enable();

            instance.show();

          }

        } else {

          // See if we can fetch this

          fetch(url.split('#')[0])

          .then(res => res.text())

          .then(html => {

            const parser = new DOMParser();

            const htmlDoc = parser.parseFromString(html, "text/html");

            const note = htmlDoc.getElementById(id);

            if (note !== null) {

              const html = processXRef(id, note);

              instance.setContent(html);

            } 

          }).finally(() => {

            instance.enable();

            instance.show();

          });

        }

      } else {

        // See if we can fetch a full url (with no hash to target)

        // This is a special case and we should probably do some content thinning / targeting

        fetch(url)

        .then(res => res.text())

        .then(html => {

          const parser = new DOMParser();

          const htmlDoc = parser.parseFromString(html, "text/html");

          const note = htmlDoc.querySelector('main.content');

          if (note !== null) {

            // This should only happen for chapter cross references

            // (since there is no id in the URL)

            // remove the first header

            if (note.children.length > 0 && note.children[0].tagName === "HEADER") {

              note.children[0].remove();

            }

            const html = processXRef(null, note);

            instance.setContent(html);

          } 

        }).finally(() => {

          instance.enable();

          instance.show();

        });

      }

    }, function(instance) {

    });

  }

      let selectedAnnoteEl;

      const selectorForAnnotation = ( cell, annotation) => {

        let cellAttr = 'data-code-cell="' + cell + '"';

        let lineAttr = 'data-code-annotation="' +  annotation + '"';

        const selector = 'span[' + cellAttr + '][' + lineAttr + ']';

        return selector;

      }

      const selectCodeLines = (annoteEl) => {

        const doc = window.document;

        const targetCell = annoteEl.getAttribute("data-target-cell");

        const targetAnnotation = annoteEl.getAttribute("data-target-annotation");

        const annoteSpan = window.document.querySelector(selectorForAnnotation(targetCell, targetAnnotation));

        const lines = annoteSpan.getAttribute("data-code-lines").split(",");

        const lineIds = lines.map((line) => {

          return targetCell + "-" + line;

        })

        let top = null;

        let height = null;

        let parent = null;

        if (lineIds.length > 0) {

            //compute the position of the single el (top and bottom and make a div)

            const el = window.document.getElementById(lineIds[0]);

            top = el.offsetTop;

            height = el.offsetHeight;

            parent = el.parentElement.parentElement;

          if (lineIds.length > 1) {

            const lastEl = window.document.getElementById(lineIds[lineIds.length - 1]);

            const bottom = lastEl.offsetTop + lastEl.offsetHeight;

            height = bottom - top;

          }

          if (top !== null && height !== null && parent !== null) {

            // cook up a div (if necessary) and position it 

            let div = window.document.getElementById("code-annotation-line-highlight");

            if (div === null) {

              div = window.document.createElement("div");

              div.setAttribute("id", "code-annotation-line-highlight");

              div.style.position = 'absolute';

              parent.appendChild(div);

            }

            div.style.top = top - 2 + "px";

            div.style.height = height + 4 + "px";

            div.style.left = 0;

            let gutterDiv = window.document.getElementById("code-annotation-line-highlight-gutter");

            if (gutterDiv === null) {

              gutterDiv = window.document.createElement("div");

              gutterDiv.setAttribute("id", "code-annotation-line-highlight-gutter");

              gutterDiv.style.position = 'absolute';

              const codeCell = window.document.getElementById(targetCell);

              const gutter = codeCell.querySelector('.code-annotation-gutter');

              gutter.appendChild(gutterDiv);

            }

            gutterDiv.style.top = top - 2 + "px";

            gutterDiv.style.height = height + 4 + "px";

          }

          selectedAnnoteEl = annoteEl;

        }

      };

      const unselectCodeLines = () => {

        const elementsIds = ["code-annotation-line-highlight", "code-annotation-line-highlight-gutter"];

        elementsIds.forEach((elId) => {

          const div = window.document.getElementById(elId);

          if (div) {

            div.remove();

          }

        });

        selectedAnnoteEl = undefined;

      };

        // Handle positioning of the toggle

    window.addEventListener(

      "resize",

      throttle(() => {

        elRect = undefined;

        if (selectedAnnoteEl) {

          selectCodeLines(selectedAnnoteEl);

        }

      }, 10)

    );

    function throttle(fn, ms) {

    let throttle = false;

    let timer;

      return (...args) => {

        if(!throttle) { // first call gets through

            fn.apply(this, args);

            throttle = true;

        } else { // all the others get throttled

            if(timer) clearTimeout(timer); // cancel #2

            timer = setTimeout(() => {

              fn.apply(this, args);

              timer = throttle = false;

            }, ms);

        }

      };

    }

      // Attach click handler to the DT

      const annoteDls = window.document.querySelectorAll('dt[data-target-cell]');

      for (const annoteDlNode of annoteDls) {

        annoteDlNode.addEventListener('click', (event) => {

          const clickedEl = event.target;

          if (clickedEl !== selectedAnnoteEl) {

            unselectCodeLines();

            const activeEl = window.document.querySelector('dt[data-target-cell].code-annotation-active');

            if (activeEl) {

              activeEl.classList.remove('code-annotation-active');

            }

            selectCodeLines(clickedEl);

            clickedEl.classList.add('code-annotation-active');

          } else {

            // Unselect the line

            unselectCodeLines();

            clickedEl.classList.remove('code-annotation-active');

          }

        });

      }

  const findCites = (el) => {

    const parentEl = el.parentElement;

    if (parentEl) {

      const cites = parentEl.dataset.cites;

      if (cites) {

        return {

          el,

          cites: cites.split(' ')

        };

      } else {

        return findCites(el.parentElement)

      }

    } else {

      return undefined;

    }

  };

  var bibliorefs = window.document.querySelectorAll('a[role="doc-biblioref"]');

  for (var i=0; i<bibliorefs.length; i++) {

    const ref = bibliorefs[i];

    const citeInfo = findCites(ref);

    if (citeInfo) {

      tippyHover(citeInfo.el, function() {

        var popup = window.document.createElement('div');

        citeInfo.cites.forEach(function(cite) {

          var citeDiv = window.document.createElement('div');

          citeDiv.classList.add('hanging-indent');

          citeDiv.classList.add('csl-entry');

          var biblioDiv = window.document.getElementById('ref-' + cite);

          if (biblioDiv) {

            citeDiv.innerHTML = biblioDiv.innerHTML;

          }

          popup.appendChild(citeDiv);

        });

        return popup.innerHTML;

      });

    }

  }

});