<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE article PUBLIC "-//NLM//DTD Journal Publishing DTD v2.3 20070202//EN" "journalpublishing.dtd">
<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" xml:lang="en" dtd-version="2.3" article-type="research-article">
  <front>
    <journal-meta>
      <journal-id journal-id-type="publisher-id">sensors</journal-id>
      <journal-title>Sensors</journal-title>
      <abbrev-journal-title abbrev-type="publisher">Sensors</abbrev-journal-title>
      <abbrev-journal-title abbrev-type="pubmed">Sensors</abbrev-journal-title>
      <issn pub-type="epub">1424-8220</issn>
      <publisher>
        <publisher-name>MDPI</publisher-name>
      </publisher>
    </journal-meta>
    <article-meta>
      <article-id pub-id-type="doi">10.3390/s16050722</article-id>
      <article-id pub-id-type="publisher-id">sensors-16-00722</article-id>
      <article-categories>
        <subj-group>
          <subject>Article</subject>
        </subj-group>
      </article-categories>
      <title-group>
        <article-title>Matrix Completion Optimization for Localization in Wireless Sensor Networks for Intelligent IoT</article-title>
      </title-group>
      <contrib-group>
        <contrib contrib-type="author">
          <name>
            <surname>Nguyen</surname>
            <given-names>Thu L. N.</given-names>
          </name>
        </contrib>
        <contrib contrib-type="author">
          <name>
            <surname>Shin</surname>
            <given-names>Yoan</given-names>
          </name>
          <xref rid="c1-sensors-16-00722" ref-type="corresp">*</xref>
        </contrib>
        <contrib contrib-type="editor">
          <name>
            <surname>Reindl</surname>
            <given-names>Leonhard M.</given-names>
          </name>
          <role>Academic Editor</role>
        </contrib>
      </contrib-group>
      <aff id="af1-sensors-16-00722">School of Electronic Engineering, Soongsil University, Seoul 156-743, Korea; <email>thunguyen@ssu.ac.kr</email></aff>
      <author-notes>
        <corresp id="c1-sensors-16-00722"><label>*</label>Correspondence: <email>yashin@ssu.ac.kr</email>; Tel.: +82-2-820-0632</corresp>
      </author-notes>
      <pub-date pub-type="epub">
        <day>18</day>
        <month>05</month>
        <year>2016</year>
      </pub-date>
      <pub-date pub-type="collection"><month>05</month>
        <year>2016</year>
      </pub-date>
      <volume>16</volume>
      <issue>5</issue>
      <elocation-id>722</elocation-id>
      <history>
        <date date-type="received">
          <day>07</day>
          <month>01</month>
          <year>2016</year>
        </date>
        <date date-type="accepted">
          <day>14</day>
          <month>05</month>
          <year>2016</year>
        </date>
      </history>
      <permissions>
        <copyright-statement>&#xA9; 2016 by the authors; licensee MDPI, Basel, Switzerland.</copyright-statement>
        <copyright-year>2016</copyright-year>
        <license>
          <p>This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC-BY) license (http://creativecommons.org/licenses/by/4.0/).</p>
        </license>
      </permissions>
      <abstract>
        <p>Localization in wireless sensor networks (WSNs) is one of the primary functions of the intelligent Internet of Things (IoT) that offers automatically discoverable services, while the localization accuracy is a key issue to evaluate the quality of those services. In this paper, we develop a framework to solve the Euclidean distance matrix completion problem, which is an important technical problem for distance-based localization in WSNs. The sensor network localization problem is described as a low-rank dimensional Euclidean distance completion problem with known nodes. The task is to find the sensor locations through recovery of missing entries of a squared distance matrix when the dimension of the data is small compared to the number of data points. We solve a relaxation optimization problem using a modification of Newton&#x2019;s method, where the cost function depends on the squared distance matrix. The solution obtained in our scheme achieves a lower complexity and can perform better if we use it as an initial guess for an interactive local search of other higher precision localization scheme. Simulation results show the effectiveness of our approach.</p>
      </abstract>
      <kwd-group>
        <kwd>Internet of Things</kwd>
        <kwd>wireless sensor network</kwd>
        <kwd>localization</kwd>
        <kwd>Euclidean distance matrix completion</kwd>
        <kwd>semi-definite programming</kwd>
        <kwd>modified Newton method</kwd>
      </kwd-group>
    </article-meta>
  </front>
  <body>
    <sec sec-type="intro" id="sec1-sensors-16-00722">
      <title>1. Introduction</title>
      <sec id="sec1dot1-sensors-16-00722">
        <title>1.1. Localization in Wireless Sensor Networks</title>
        <p>Localization of sensor nodes is a challenging issue in wireless sensor networks (WSNs) for intelligent Internet of Things (IoT). Localization systems are not only for location identification but also provide information for routing, density control, tracking and a number of other communication network applications which integrate in many technologies of IoT. In general, the sensor positioning process has two steps. First, we choose the signal parameters to describe the location information between sensors. Second, we use some parametric methods for estimating the sensor positions based on the signal parameters in the first step. For the first step, GPS-based localization systems have a high degree of accuracy and offer global location information. However, alternative solutions for GPS are required, which are cost effective, rapidly deployable and can operate in diverse conditions, especially for indoor or non-line-of-sight environments. For these reasons, more suitable localization algorithms for WSNs need to be investigated. Some existing localization approaches such as time-of-arrival (TOA), time-difference-of-arrival, and angle-of-arrival achieve accurate localization results, but require high cost, complicated timing and synchronization. On the other hand, received signal strength (RSS) measurements are quite simple to obtain [<xref ref-type="bibr" rid="B1-sensors-16-00722">1</xref>,<xref ref-type="bibr" rid="B2-sensors-16-00722">2</xref>,<xref ref-type="bibr" rid="B3-sensors-16-00722">3</xref>].</p>
        <p>In this paper, we study sensor network localization problems in embedding dimension, given anchors and the RSS information between sensors. The anchors are located at fixed known sensor positions, and distances between unknown sensors and anchors are estimated from RSS measurements. Our goal is to approximate all sensor locations by using only a partial Euclidean distance matrix for the second step. Recently, many solution techniques for this problem have been proposed, such as semidefinite programming relaxation (SDP) and solvers [<xref ref-type="bibr" rid="B4-sensors-16-00722">4</xref>,<xref ref-type="bibr" rid="B5-sensors-16-00722">5</xref>,<xref ref-type="bibr" rid="B6-sensors-16-00722">6</xref>], multidimensional scaling (MDS) and its improvements [<xref ref-type="bibr" rid="B7-sensors-16-00722">7</xref>,<xref ref-type="bibr" rid="B8-sensors-16-00722">8</xref>,<xref ref-type="bibr" rid="B9-sensors-16-00722">9</xref>], heuristics [<xref ref-type="bibr" rid="B10-sensors-16-00722">10</xref>], Euclidean distance matrix completion (EDMC) [<xref ref-type="bibr" rid="B11-sensors-16-00722">11</xref>], to name a few. However, most of previous approaches are not scalable and require high computational complexity, so that we try to reduce computational complexity by using a modified iterative Newton&#x2019;s algorithm for a cost function.</p>
        <p><italic>Notations</italic>: The following notations are used throughout our paper. <inline-formula>
          <mml:math id="mm1" display="block">
            <mml:semantics>
              <mml:msup>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:mo>&#xB7;</mml:mo>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
                <mml:mi>T</mml:mi>
              </mml:msup>
            </mml:semantics>
          </mml:math>
        </inline-formula> and <inline-formula>
          <mml:math id="mm2" display="block">
            <mml:semantics>
              <mml:msup>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:mo>&#xB7;</mml:mo>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
                <mml:mrow>
                  <mml:mo>-</mml:mo>
                  <mml:mn>1</mml:mn>
                </mml:mrow>
              </mml:msup>
            </mml:semantics>
          </mml:math>
        </inline-formula> denote the transpose and the inverse operations. &#x2218; denotes the Hadamard product. <inline-formula>
          <mml:math id="mm3" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mrow>
                  <mml:mo>|</mml:mo>
                  <mml:mo>|</mml:mo>
                </mml:mrow>
                <mml:mo>&#xB7;</mml:mo>
                <mml:msub>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mo>|</mml:mo>
                  </mml:mrow>
                  <mml:mn>2</mml:mn>
                </mml:msub>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> and <inline-formula>
          <mml:math id="mm4" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mrow>
                  <mml:mo>|</mml:mo>
                  <mml:mo>|</mml:mo>
                </mml:mrow>
                <mml:mo>&#xB7;</mml:mo>
                <mml:msub>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mo>|</mml:mo>
                  </mml:mrow>
                  <mml:mi>F</mml:mi>
                </mml:msub>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> denote the <inline-formula>
          <mml:math id="mm5" display="block">
            <mml:semantics>
              <mml:msub>
                <mml:mi>&#x2113;</mml:mi>
                <mml:mn>2</mml:mn>
              </mml:msub>
            </mml:semantics>
          </mml:math>
        </inline-formula>-norm and the Frobenius matrix norm, respectively. The notation <inline-formula>
          <mml:math id="mm6" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="bold">w</mml:mi>
                <mml:mo>&#x223C;</mml:mo>
                <mml:mi mathvariant="script">N</mml:mi>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi>&#x3BC;</mml:mi>
                <mml:mo>,</mml:mo>
                <mml:msup>
                  <mml:mi>&#x3C3;</mml:mi>
                  <mml:mn>2</mml:mn>
                </mml:msup>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> means that <inline-formula>
          <mml:math id="mm7" display="block">
            <mml:semantics>
              <mml:mi mathvariant="bold">w</mml:mi>
            </mml:semantics>
          </mml:math>
        </inline-formula> is distributed according to the normal Gaussian distribution with the mean <italic>&#x3BC;</italic> and the covariance <inline-formula>
          <mml:math id="mm8" display="block">
            <mml:semantics>
              <mml:msup>
                <mml:mi>&#x3C3;</mml:mi>
                <mml:mn>2</mml:mn>
              </mml:msup>
            </mml:semantics>
          </mml:math>
        </inline-formula>. The operator <inline-formula>
          <mml:math id="mm9" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mo form="prefix">diag</mml:mo>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi mathvariant="bold">A</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> returns a column vector of the main diagonal elements of the matrix <inline-formula>
          <mml:math id="mm10" display="block">
            <mml:semantics>
              <mml:mi mathvariant="bold">A</mml:mi>
            </mml:semantics>
          </mml:math>
        </inline-formula>. For vectors, <inline-formula>
          <mml:math id="mm11" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mo form="prefix">arg</mml:mo>
                <mml:mo movablelimits="true" form="prefix">min</mml:mo>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi mathvariant="bold">x</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> returns the indices of the smallest elements in <inline-formula>
          <mml:math id="mm12" display="block">
            <mml:semantics>
              <mml:mi mathvariant="bold">x</mml:mi>
            </mml:semantics>
          </mml:math>
        </inline-formula>. For two arbitrary symmetric matrices <inline-formula>
          <mml:math id="mm13" display="block">
            <mml:semantics>
              <mml:mi mathvariant="bold">A</mml:mi>
            </mml:semantics>
          </mml:math>
        </inline-formula> and <inline-formula>
          <mml:math id="mm14" display="block">
            <mml:semantics>
              <mml:mi mathvariant="bold">B</mml:mi>
            </mml:semantics>
          </mml:math>
        </inline-formula>, <inline-formula>
          <mml:math id="mm15" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="bold">A</mml:mi>
                <mml:mo>&#x2AB0;</mml:mo>
                <mml:mi mathvariant="bold">B</mml:mi>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> means <inline-formula>
          <mml:math id="mm16" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="bold">A</mml:mi>
                <mml:mo>-</mml:mo>
                <mml:mi mathvariant="bold">B</mml:mi>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> is positive semidefinite. <inline-formula>
          <mml:math id="mm17" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mo form="prefix">grad</mml:mo>
                <mml:mi>f</mml:mi>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> and <inline-formula>
          <mml:math id="mm18" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mo form="prefix">Hess</mml:mo>
                <mml:mi>f</mml:mi>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> denote the gradient and the Hessian vectors representing the first and the second partial derivatives.</p>
      </sec>
      <sec id="sec1dot2-sensors-16-00722">
        <title>1.2. Euclidean Distance Matrix Completion</title>
        <p>Consider a set of <italic>n</italic> points (or sensors) with locations <inline-formula>
          <mml:math id="mm19" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:msub>
                  <mml:mi mathvariant="bold">x</mml:mi>
                  <mml:mn>1</mml:mn>
                </mml:msub>
                <mml:mo>,</mml:mo>
                <mml:mo>&#x22EF;</mml:mo>
                <mml:mo>,</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">x</mml:mi>
                  <mml:mi>n</mml:mi>
                </mml:msub>
                <mml:mo>&#x2208;</mml:mo>
                <mml:msup>
                  <mml:mi mathvariant="double-struck">R</mml:mi>
                  <mml:mi>r</mml:mi>
                </mml:msup>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> (in practice, <inline-formula>
          <mml:math id="mm20" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi>r</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mn>2</mml:mn>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> or 3). Denote <inline-formula>
          <mml:math id="mm21" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mo>&#x2208;</mml:mo>
                <mml:msup>
                  <mml:mi mathvariant="bold">R</mml:mi>
                  <mml:mrow>
                    <mml:mi>n</mml:mi>
                    <mml:mo>&#xD7;</mml:mo>
                    <mml:mi>n</mml:mi>
                  </mml:mrow>
                </mml:msup>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> as an Euclidean distance matrix whose entries are the squared pairwise distances between <italic>n</italic> points by setting
        <disp-formula id="FD1-sensors-16-00722">
          <label>(1)</label>
          <mml:math id="mm22" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:msub>
                  <mml:mi mathvariant="bold">D</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>=</mml:mo>
                <mml:mrow>
                  <mml:mo>|</mml:mo>
                  <mml:mo>|</mml:mo>
                </mml:mrow>
                <mml:msub>
                  <mml:mi mathvariant="bold">x</mml:mi>
                  <mml:mi>i</mml:mi>
                </mml:msub>
                <mml:mo>-</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">x</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:msub>
                <mml:msubsup>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mo>|</mml:mo>
                  </mml:mrow>
                  <mml:mn>2</mml:mn>
                  <mml:mn>2</mml:mn>
                </mml:msubsup>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </disp-formula></p>
        <p>It is easy to see that the rank of <inline-formula>
          <mml:math id="mm23" display="block">
            <mml:semantics>
              <mml:mi mathvariant="bold">D</mml:mi>
            </mml:semantics>
          </mml:math>
        </inline-formula> is upper bound by <inline-formula>
          <mml:math id="mm24" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi>r</mml:mi>
                <mml:mo>+</mml:mo>
                <mml:mn>2</mml:mn>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> which is very small compared to the number of data points <italic>n</italic>, especially when <italic>n</italic> becomes large. The set of all Euclidean distance matrices in <inline-formula>
          <mml:math id="mm25" display="block">
            <mml:semantics>
              <mml:msup>
                <mml:mi mathvariant="bold">R</mml:mi>
                <mml:mrow>
                  <mml:mi>n</mml:mi>
                  <mml:mo>&#xD7;</mml:mo>
                  <mml:mi>n</mml:mi>
                </mml:mrow>
              </mml:msup>
            </mml:semantics>
          </mml:math>
        </inline-formula> is denoted as <inline-formula>
          <mml:math id="mm26" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mo form="prefix">EDM</mml:mo>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi>n</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>. We associate a weighted undirected graph <inline-formula>
          <mml:math id="mm27" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi>G</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi>V</mml:mi>
                <mml:mo>,</mml:mo>
                <mml:mi>E</mml:mi>
                <mml:mo>,</mml:mo>
                <mml:mi>W</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> with <inline-formula>
          <mml:math id="mm28" display="block">
            <mml:semantics>
              <mml:mi mathvariant="bold">D</mml:mi>
            </mml:semantics>
          </mml:math>
        </inline-formula>, where the vertex set <inline-formula>
          <mml:math id="mm29" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi>V</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mo>{</mml:mo>
                <mml:mn>1</mml:mn>
                <mml:mo>,</mml:mo>
                <mml:mo>&#x22EF;</mml:mo>
                <mml:mo>,</mml:mo>
                <mml:mi>n</mml:mi>
                <mml:mo>}</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>, the edge set <inline-formula>
          <mml:math id="mm30" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi>E</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mo>{</mml:mo>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi>i</mml:mi>
                <mml:mo>,</mml:mo>
                <mml:mi>j</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
                <mml:mo>:</mml:mo>
                <mml:mi>i</mml:mi>
                <mml:mo>&#x2260;</mml:mo>
                <mml:mi>j</mml:mi>
                <mml:mo>,</mml:mo>
                <mml:mspace width="3.33333pt"/>
                <mml:mtext>and</mml:mtext>
                <mml:mspace width="3.33333pt"/>
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mspace width="3.33333pt"/>
                <mml:mtext>is</mml:mtext>
                <mml:mspace width="4.pt"/>
                <mml:mtext>specified</mml:mtext>
                <mml:mo>}</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>, and the positive edge weight <inline-formula>
          <mml:math id="mm31" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi>W</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mi>w</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> with <inline-formula>
          <mml:math id="mm32" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:msub>
                  <mml:mi>w</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>=</mml:mo>
                <mml:msqrt>
                  <mml:msub>
                    <mml:mi mathvariant="bold">D</mml:mi>
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mi>j</mml:mi>
                    </mml:mrow>
                  </mml:msub>
                </mml:msqrt>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> for all <inline-formula>
          <mml:math id="mm33" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi>i</mml:mi>
                <mml:mo>,</mml:mo>
                <mml:mi>j</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
                <mml:mo>&#x2208;</mml:mo>
                <mml:mi>E</mml:mi>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>. Let <inline-formula>
          <mml:math id="mm34" display="block">
            <mml:semantics>
              <mml:mi mathvariant="bold">H</mml:mi>
            </mml:semantics>
          </mml:math>
        </inline-formula> be the matrix whose entries are
        <disp-formula id="FD2-sensors-16-00722">
          <label>(2)</label>
          <mml:math id="mm35" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:msub>
                  <mml:mi>h</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>=</mml:mo>
                <mml:msub>
                  <mml:mi>h</mml:mi>
                  <mml:mrow>
                    <mml:mi>j</mml:mi>
                    <mml:mi>i</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>=</mml:mo>
                <mml:mfenced separators="" open="{" close="">
                  <mml:mtable>
                    <mml:mtr>
                      <mml:mtd columnalign="left">
                        <mml:mrow>
                          <mml:mn>1</mml:mn>
                          <mml:mspace width="1.em"/>
                        </mml:mrow>
                      </mml:mtd>
                      <mml:mtd columnalign="left">
                        <mml:mrow>
                          <mml:mtext>if</mml:mtext>
                          <mml:mspace width="3.33333pt"/>
                          <mml:mo  stretchy="false">(</mml:mo>
                          <mml:mi>i</mml:mi>
                          <mml:mo>,</mml:mo>
                          <mml:mi>j</mml:mi>
                          <mml:mo  stretchy="false">)</mml:mo>
                          <mml:mo>&#x2208;</mml:mo>
                          <mml:mi>E</mml:mi>
                        </mml:mrow>
                      </mml:mtd>
                    </mml:mtr>
                    <mml:mtr>
                      <mml:mtd columnalign="left">
                        <mml:mrow>
                          <mml:mn>0</mml:mn>
                          <mml:mspace width="1.em"/>
                        </mml:mrow>
                      </mml:mtd>
                      <mml:mtd columnalign="left">
                        <mml:mtext>otherwise</mml:mtext>
                      </mml:mtd>
                    </mml:mtr>
                  </mml:mtable>
                </mml:mfenced>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </disp-formula></p>
        <p>Given the observation data <inline-formula>
          <mml:math id="mm36" display="block">
            <mml:semantics>
              <mml:mover accent="true">
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mo>&#x2DC;</mml:mo>
              </mml:mover>
            </mml:semantics>
          </mml:math>
        </inline-formula>, the low-rank distance matrix completion problem states as
        <disp-formula id="FD3-sensors-16-00722">
          <label>(3)</label>
          <mml:math id="mm37" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:munder>
                  <mml:mo movablelimits="true" form="prefix">min</mml:mo>
                  <mml:mrow>
                    <mml:mi mathvariant="bold">D</mml:mi>
                    <mml:mo>&#x2208;</mml:mo>
                    <mml:mo form="prefix">EDM</mml:mo>
                    <mml:mo  stretchy="false">(</mml:mo>
                    <mml:mi>n</mml:mi>
                    <mml:mo  stretchy="false">)</mml:mo>
                  </mml:mrow>
                </mml:munder>
                <mml:mrow>
                  <mml:mo>|</mml:mo>
                  <mml:mo>|</mml:mo>
                  <mml:mi mathvariant="bold">H</mml:mi>
                </mml:mrow>
                <mml:mo>&#x2218;</mml:mo>
                <mml:mrow>
                  <mml:mo stretchy="false">(</mml:mo>
                  <mml:mover accent="true">
                    <mml:mi mathvariant="bold">D</mml:mi>
                    <mml:mo>&#x2DC;</mml:mo>
                  </mml:mover>
                  <mml:mo>-</mml:mo>
                  <mml:mi mathvariant="bold">D</mml:mi>
                  <mml:mo stretchy="false">)</mml:mo>
                </mml:mrow>
                <mml:msubsup>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mo>|</mml:mo>
                  </mml:mrow>
                  <mml:mi>F</mml:mi>
                  <mml:mn>2</mml:mn>
                </mml:msubsup>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </disp-formula></p>
        <p>To find out the relationship between positive semidefinite matrices and Euclidean distance matrices, let
        <disp-formula id="FD4-sensors-16-00722">
          <label>(4)</label>
          <mml:math id="mm38" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mfenced open="[" close="]">
                  <mml:mtable>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:msubsup>
                          <mml:mi mathvariant="bold">x</mml:mi>
                          <mml:mn>1</mml:mn>
                          <mml:mi>T</mml:mi>
                        </mml:msubsup>
                      </mml:mtd>
                    </mml:mtr>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mo>&#x22EE;</mml:mo>
                      </mml:mtd>
                    </mml:mtr>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:msubsup>
                          <mml:mi mathvariant="bold">x</mml:mi>
                          <mml:mi>n</mml:mi>
                          <mml:mi>T</mml:mi>
                        </mml:msubsup>
                      </mml:mtd>
                    </mml:mtr>
                  </mml:mtable>
                </mml:mfenced>
                <mml:mspace width="3.33333pt"/>
                <mml:mtext>and</mml:mtext>
                <mml:mspace width="1.em"/>
                <mml:mi mathvariant="bold">Y</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:msup>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mi>T</mml:mi>
                </mml:msup>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </disp-formula></p>
        <p>Then, we can observe that
        <disp-formula id="FD5-sensors-16-00722">
          <label>(5)</label>
          <mml:math id="mm39" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:msub>
                  <mml:mi mathvariant="bold">D</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>=</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">Y</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>i</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>-</mml:mo>
                <mml:mn>2</mml:mn>
                <mml:msub>
                  <mml:mi mathvariant="bold">Y</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>+</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">Y</mml:mi>
                  <mml:mrow>
                    <mml:mi>j</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </disp-formula></p>
        <p>Hence, <inline-formula>
          <mml:math id="mm40" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mi>&#x3BA;</mml:mi>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi mathvariant="bold">Y</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>, where <inline-formula>
          <mml:math id="mm41" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi>&#x3BA;</mml:mi>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mo>&#xB7;</mml:mo>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> is a linear map defined as
        <disp-formula id="FD6-sensors-16-00722">
          <label>(6)</label>
          <mml:math id="mm42" display="block">
            <mml:semantics>
              <mml:mtable displaystyle="true">
                <mml:mtr>
                  <mml:mtd columnalign="right">
                    <mml:mrow>
                      <mml:mi>&#x3BA;</mml:mi>
                      <mml:mo>:</mml:mo>
                      <mml:mspace width="1.em"/>
                      <mml:msup>
                        <mml:mi mathvariant="script">S</mml:mi>
                        <mml:mi>n</mml:mi>
                      </mml:msup>
                    </mml:mrow>
                  </mml:mtd>
                  <mml:mtd columnalign="left">
                    <mml:mrow>
                      <mml:mo>&#x2192;</mml:mo>
                      <mml:msup>
                        <mml:mi mathvariant="script">S</mml:mi>
                        <mml:mi>n</mml:mi>
                      </mml:msup>
                    </mml:mrow>
                  </mml:mtd>
                </mml:mtr>
                <mml:mtr>
                  <mml:mtd columnalign="right">
                    <mml:mi mathvariant="bold">Y</mml:mi>
                  </mml:mtd>
                  <mml:mtd columnalign="left">
                    <mml:mrow>
                      <mml:mo>&#x21A6;</mml:mo>
                      <mml:mi>&#x3BA;</mml:mi>
                      <mml:mrow>
                        <mml:mo  stretchy="false">(</mml:mo>
                        <mml:mi mathvariant="bold">Y</mml:mi>
                        <mml:mo  stretchy="false">)</mml:mo>
                      </mml:mrow>
                      <mml:mo>=</mml:mo>
                      <mml:mo form="prefix">diag</mml:mo>
                      <mml:mrow>
                        <mml:mo  stretchy="false">(</mml:mo>
                        <mml:mi mathvariant="bold">Y</mml:mi>
                        <mml:mo  stretchy="false">)</mml:mo>
                      </mml:mrow>
                      <mml:msup>
                        <mml:mi mathvariant="bold">e</mml:mi>
                        <mml:mi>T</mml:mi>
                      </mml:msup>
                      <mml:mo>+</mml:mo>
                      <mml:mi mathvariant="bold">e</mml:mi>
                      <mml:mo form="prefix">diag</mml:mo>
                      <mml:msup>
                        <mml:mrow>
                          <mml:mo  stretchy="false">(</mml:mo>
                          <mml:mi mathvariant="bold">Y</mml:mi>
                          <mml:mo  stretchy="false">)</mml:mo>
                        </mml:mrow>
                        <mml:mi>T</mml:mi>
                      </mml:msup>
                      <mml:mo>-</mml:mo>
                      <mml:mn>2</mml:mn>
                      <mml:mi mathvariant="bold">Y</mml:mi>
                    </mml:mrow>
                  </mml:mtd>
                </mml:mtr>
              </mml:mtable>
            </mml:semantics>
          </mml:math>
        </disp-formula></p>
        <p>Here, <inline-formula>
          <mml:math id="mm43" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:msup>
                  <mml:mi mathvariant="script">S</mml:mi>
                  <mml:mi>n</mml:mi>
                </mml:msup>
                <mml:mo>=</mml:mo>
                <mml:mrow>
                  <mml:mo>{</mml:mo>
                  <mml:mi mathvariant="bold">Y</mml:mi>
                  <mml:mo>&#x2208;</mml:mo>
                  <mml:msup>
                    <mml:mi mathvariant="double-struck">R</mml:mi>
                    <mml:mrow>
                      <mml:mi>n</mml:mi>
                      <mml:mo>&#xD7;</mml:mo>
                      <mml:mi>n</mml:mi>
                    </mml:mrow>
                  </mml:msup>
                  <mml:mo>:</mml:mo>
                  <mml:mi mathvariant="bold">Y</mml:mi>
                  <mml:mo>=</mml:mo>
                  <mml:msup>
                    <mml:mi mathvariant="bold">Y</mml:mi>
                    <mml:mi>T</mml:mi>
                  </mml:msup>
                  <mml:mo>}</mml:mo>
                </mml:mrow>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> and <inline-formula>
          <mml:math id="mm44" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="bold">e</mml:mi>
                <mml:mo>&#x2208;</mml:mo>
                <mml:msup>
                  <mml:mi mathvariant="double-struck">R</mml:mi>
                  <mml:mi>n</mml:mi>
                </mml:msup>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> is the vector of all ones. The problem Equation (<xref ref-type="disp-formula" rid="FD3-sensors-16-00722">3</xref>) is equivalent to
        <disp-formula id="FD7-sensors-16-00722">
          <label>(7)</label>
          <mml:math id="mm45" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:munder>
                  <mml:mo movablelimits="true" form="prefix">min</mml:mo>
                  <mml:mrow>
                    <mml:mi mathvariant="bold">Y</mml:mi>
                    <mml:mo>&#x2AB0;</mml:mo>
                    <mml:mn>0</mml:mn>
                    <mml:mo>,</mml:mo>
                    <mml:mi mathvariant="bold">Y</mml:mi>
                    <mml:mo>&#x2208;</mml:mo>
                    <mml:mi>E</mml:mi>
                  </mml:mrow>
                </mml:munder>
                <mml:mrow>
                  <mml:mo>|</mml:mo>
                  <mml:mo>|</mml:mo>
                  <mml:mi mathvariant="bold">H</mml:mi>
                </mml:mrow>
                <mml:mo>&#x2218;</mml:mo>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:mover accent="true">
                    <mml:mi mathvariant="bold">D</mml:mi>
                    <mml:mo>&#x2DC;</mml:mo>
                  </mml:mover>
                  <mml:mo>-</mml:mo>
                  <mml:mi>&#x3BA;</mml:mi>
                  <mml:mrow>
                    <mml:mo  stretchy="false">(</mml:mo>
                    <mml:mi mathvariant="bold">Y</mml:mi>
                    <mml:mo  stretchy="false">)</mml:mo>
                  </mml:mrow>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
                <mml:msubsup>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mo>|</mml:mo>
                  </mml:mrow>
                  <mml:mi>F</mml:mi>
                  <mml:mn>2</mml:mn>
                </mml:msubsup>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </disp-formula></p>
        <p>Since <inline-formula>
          <mml:math id="mm46" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mo form="prefix">rank</mml:mo>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
                <mml:mo>&#x2264;</mml:mo>
                <mml:mi>r</mml:mi>
                <mml:mo>+</mml:mo>
                <mml:mn>2</mml:mn>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>, we can solve a sequence of non-convex problems as the following rank constrained semidefinite optimization problem
        <disp-formula id="FD8-sensors-16-00722">
          <label>(8)</label>
          <mml:math id="mm47" display="block">
            <mml:semantics>
              <mml:mtable displaystyle="true">
                <mml:mtr>
                  <mml:mtd columnalign="right">
                    <mml:mrow>
                      <mml:munder>
                        <mml:mo movablelimits="true" form="prefix">min</mml:mo>
                        <mml:mrow>
                          <mml:mi mathvariant="bold">Y</mml:mi>
                          <mml:mo>&#x2AB0;</mml:mo>
                          <mml:mn>0</mml:mn>
                          <mml:mo>,</mml:mo>
                          <mml:mi mathvariant="bold">Y</mml:mi>
                          <mml:mo>&#x2208;</mml:mo>
                          <mml:mi>E</mml:mi>
                        </mml:mrow>
                      </mml:munder>
                      <mml:mspace width="1.em"/>
                    </mml:mrow>
                  </mml:mtd>
                  <mml:mtd columnalign="left">
                    <mml:mrow>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mo>|</mml:mo>
                        <mml:mi mathvariant="bold">H</mml:mi>
                      </mml:mrow>
                      <mml:mo>&#x2218;</mml:mo>
                      <mml:mrow>
                        <mml:mo stretchy="false">(</mml:mo>
                        <mml:mover accent="true">
                          <mml:mi mathvariant="bold">D</mml:mi>
                          <mml:mo>&#x2DC;</mml:mo>
                        </mml:mover>
                        <mml:mo>-</mml:mo>
                        <mml:mi>&#x3BA;</mml:mi>
                        <mml:mrow>
                          <mml:mo  stretchy="false">(</mml:mo>
                          <mml:mi mathvariant="bold">Y</mml:mi>
                          <mml:mo  stretchy="false">)</mml:mo>
                        </mml:mrow>
                        <mml:mo stretchy="false">)</mml:mo>
                      </mml:mrow>
                      <mml:msubsup>
                        <mml:mrow>
                          <mml:mo>|</mml:mo>
                          <mml:mo>|</mml:mo>
                        </mml:mrow>
                        <mml:mi>F</mml:mi>
                        <mml:mn>2</mml:mn>
                      </mml:msubsup>
                    </mml:mrow>
                  </mml:mtd>
                </mml:mtr>
                <mml:mtr>
                  <mml:mtd columnalign="right">
                    <mml:mrow>
                      <mml:mtext>subject</mml:mtext>
                      <mml:mspace width="4.pt"/>
                      <mml:mtext>to</mml:mtext>
                      <mml:mspace width="1.em"/>
                    </mml:mrow>
                  </mml:mtd>
                  <mml:mtd columnalign="left">
                    <mml:mrow>
                      <mml:mo form="prefix">rank</mml:mo>
                      <mml:mo  stretchy="false">(</mml:mo>
                      <mml:mi mathvariant="bold">Y</mml:mi>
                      <mml:mo  stretchy="false">)</mml:mo>
                      <mml:mo>=</mml:mo>
                      <mml:mi>&#x3C1;</mml:mi>
                    </mml:mrow>
                  </mml:mtd>
                </mml:mtr>
              </mml:mtable>
            </mml:semantics>
          </mml:math>
        </disp-formula></p>
        <p>By screening the value from <inline-formula>
          <mml:math id="mm48" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi>&#x3C1;</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mn>1</mml:mn>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> to <inline-formula>
          <mml:math id="mm49" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi>&#x3C1;</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mi>r</mml:mi>
                <mml:mo>+</mml:mo>
                <mml:mn>2</mml:mn>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>, the solution presented in [<xref ref-type="bibr" rid="B12-sensors-16-00722">12</xref>] guarantees a monotonic convergence to the original solution of Equation (<xref ref-type="disp-formula" rid="FD7-sensors-16-00722">7</xref>).</p>
      </sec>
      <sec id="sec1dot3-sensors-16-00722">
        <title>1.3. Contribution of the Paper</title>
        <p>In order to solve Equation (<xref ref-type="disp-formula" rid="FD7-sensors-16-00722">7</xref>), several approaches have been studied in [<xref ref-type="bibr" rid="B4-sensors-16-00722">4</xref>,<xref ref-type="bibr" rid="B5-sensors-16-00722">5</xref>,<xref ref-type="bibr" rid="B6-sensors-16-00722">6</xref>,<xref ref-type="bibr" rid="B7-sensors-16-00722">7</xref>,<xref ref-type="bibr" rid="B8-sensors-16-00722">8</xref>,<xref ref-type="bibr" rid="B9-sensors-16-00722">9</xref>]. The conventional MDS method transforms the pairwise distance information into the relative coordinates of sensor nodes [<xref ref-type="bibr" rid="B4-sensors-16-00722">4</xref>,<xref ref-type="bibr" rid="B5-sensors-16-00722">5</xref>,<xref ref-type="bibr" rid="B6-sensors-16-00722">6</xref>]. Thus, the global solution only obtained when we use all pairwise distance measurements of sensors, which is impractical. To overcome this problem, the authors in [<xref ref-type="bibr" rid="B7-sensors-16-00722">7</xref>,<xref ref-type="bibr" rid="B8-sensors-16-00722">8</xref>] proposed the distributed weighted MDS (WMDS/dwMDS) method, while the authors in [<xref ref-type="bibr" rid="B9-sensors-16-00722">9</xref>] proposed the MDS-MAP. Both methods are basically based on either the linearized least square estimator for TOA information or the biased RSS-based estimators, so that the estimated solutions can be obtained explicit and much easier than the conventional MDS. However, their accuracy is not good when the variance of the measurement noise is large.</p>
        <p>In this paper, our goal is to design a numerical estimator especially for the RSS-based localization systems. This estimator is based on the RSS measurements rather than pairwise distance information. We first formulate the sensor localization problem as a relaxation of SDP, then the solution can be numerically obtained via a modification of the Newton&#x2019;s method as long as the RSS measurements are valid. This result is mainly used for coarse localization strategy, <italic>i.e.</italic>, reducing the region of interest and computation time for the fine localization stage, where the estimated solutions can be used as a starting point for other fine localization algorithms such as dwMDS and MDS-MAP, <italic>etc</italic>. This localization scheme provides a low-cost, low-complexity, and easy-implementation solution, thus there also exists tradeoff between the location accuracy and the computation complexity compared with other techniques.</p>
        <p>The organization of this paper is as follows. In <xref ref-type="sec" rid="sec2-sensors-16-00722">Section 2</xref>, we formulate the sensor network localization problem as a reduction of SDP. In <xref ref-type="sec" rid="sec3-sensors-16-00722">Section 3</xref>, we describe our approach for node localization in WSNs by using a modification of the Newton&#x2019;s method. Then, numerical evaluation results are presented in <xref ref-type="sec" rid="sec4-sensors-16-00722">Section 4</xref>, followed by concluding remarks in <xref ref-type="sec" rid="sec5-sensors-16-00722">Section 5</xref>.</p>
      </sec>
    </sec>
    <sec id="sec2-sensors-16-00722">
      <title>2. Problem Formulation of Sensor Network Localization</title>
      <p>Consider a sensor network consisting of <italic>n</italic> wireless sensors at the locations <inline-formula>
        <mml:math id="mm50" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">p</mml:mi>
                <mml:mn>1</mml:mn>
              </mml:msub>
              <mml:mo>,</mml:mo>
              <mml:mo>&#x22EF;</mml:mo>
              <mml:mo>,</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">p</mml:mi>
                <mml:mi>n</mml:mi>
              </mml:msub>
              <mml:mo>&#x2208;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="double-struck">R</mml:mi>
                <mml:mi>r</mml:mi>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, where <italic>r</italic> is the embedding dimension. As defined in the previous section, <inline-formula>
        <mml:math id="mm51" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">D</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula> represents the Euclidean distances between sensors within given radio range <italic>R</italic>. The embedding dimension is the smallest integer <italic>r</italic> satisfying
      <disp-formula>
        <mml:math id="mm52" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>r</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mo movablelimits="true" form="prefix">min</mml:mo>
              <mml:mo>{</mml:mo>
              <mml:mi>t</mml:mi>
              <mml:mo>:</mml:mo>
              <mml:mo>&#x2203;</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">p</mml:mi>
                <mml:mn>1</mml:mn>
              </mml:msub>
              <mml:mo>,</mml:mo>
              <mml:mo>&#x22EF;</mml:mo>
              <mml:mo>,</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">p</mml:mi>
                <mml:mi>n</mml:mi>
              </mml:msub>
              <mml:mo>&#x2208;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="double-struck">R</mml:mi>
                <mml:mi>r</mml:mi>
              </mml:msup>
              <mml:mo>:</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:mo>|</mml:mo>
              <mml:mo>|</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">p</mml:mi>
                <mml:mi>i</mml:mi>
              </mml:msub>
              <mml:mo>-</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">p</mml:mi>
                <mml:mi>j</mml:mi>
              </mml:msub>
              <mml:mo>|</mml:mo>
              <mml:msubsup>
                <mml:mo>|</mml:mo>
                <mml:mn>2</mml:mn>
                <mml:mn>2</mml:mn>
              </mml:msubsup>
              <mml:mo>,</mml:mo>
              <mml:mspace width="3.33333pt"/>
              <mml:mo>&#x2200;</mml:mo>
              <mml:mi>i</mml:mi>
              <mml:mo>,</mml:mo>
              <mml:mi>j</mml:mi>
              <mml:mo>}</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula></p>
      <p>We denote the locations of <italic>m</italic> known anchor nodes as <inline-formula>
        <mml:math id="mm53" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">a</mml:mi>
                <mml:mn>1</mml:mn>
              </mml:msub>
              <mml:mo>,</mml:mo>
              <mml:mo>&#x22EF;</mml:mo>
              <mml:mo>,</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">a</mml:mi>
                <mml:mi>m</mml:mi>
              </mml:msub>
              <mml:mo>&#x2208;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="double-struck">R</mml:mi>
                <mml:mi>r</mml:mi>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. Let <inline-formula>
        <mml:math id="mm54" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msup>
                <mml:mi mathvariant="bold">A</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msup>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">a</mml:mi>
                  <mml:mn>1</mml:mn>
                </mml:msub>
                <mml:mo>,</mml:mo>
                <mml:mo>&#x22EF;</mml:mo>
                <mml:mo>,</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">a</mml:mi>
                  <mml:mi>m</mml:mi>
                </mml:msub>
                <mml:mo>]</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, and <inline-formula>
        <mml:math id="mm55" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msup>
                <mml:mi mathvariant="bold">X</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msup>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">p</mml:mi>
                  <mml:mn>1</mml:mn>
                </mml:msub>
                <mml:mo>,</mml:mo>
                <mml:mo>&#x22EF;</mml:mo>
                <mml:mo>,</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">p</mml:mi>
                  <mml:mrow>
                    <mml:mi>n</mml:mi>
                    <mml:mo>-</mml:mo>
                    <mml:mi>m</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>]</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> represents the unknown sensor nodes. In the sensor network localization problems, we ignore the distinction between the anchors and the other sensors, hence we identify <inline-formula>
        <mml:math id="mm56" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi mathvariant="bold">a</mml:mi>
              <mml:mi>i</mml:mi>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> with <inline-formula>
        <mml:math id="mm57" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">p</mml:mi>
                <mml:mrow>
                  <mml:mi>n</mml:mi>
                  <mml:mo>-</mml:mo>
                  <mml:mi>m</mml:mi>
                  <mml:mo>+</mml:mo>
                  <mml:mi>i</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mspace width="3.33333pt"/>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi>i</mml:mi>
                <mml:mo>=</mml:mo>
                <mml:mn>1</mml:mn>
                <mml:mo>,</mml:mo>
                <mml:mo>&#x22EF;</mml:mo>
                <mml:mo>,</mml:mo>
                <mml:mi>m</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> and set
      <disp-formula id="FD9-sensors-16-00722">
        <label>(9)</label>
        <mml:math id="mm58" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msup>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msup>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:msup>
                  <mml:mi mathvariant="bold">X</mml:mi>
                  <mml:mi>T</mml:mi>
                </mml:msup>
                <mml:mspace width="1.em"/>
                <mml:msup>
                  <mml:mi mathvariant="bold">A</mml:mi>
                  <mml:mi>T</mml:mi>
                </mml:msup>
                <mml:mo>]</mml:mo>
              </mml:mrow>
              <mml:mo>&#x2208;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="double-struck">R</mml:mi>
                <mml:mrow>
                  <mml:mi>n</mml:mi>
                  <mml:mo>&#xD7;</mml:mo>
                  <mml:mi>r</mml:mi>
                </mml:mrow>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula></p>
      <p>We also assume that there are a sufficient number of anchors, which makes our problem not be realized in a smaller embedding dimension.</p>
      <p>Denoting the distance between the unknown node <italic>i</italic> and the anchor <italic>j</italic> as <inline-formula>
        <mml:math id="mm59" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi>&#x3C4;</mml:mi>
              <mml:mrow>
                <mml:mi>i</mml:mi>
                <mml:mi>j</mml:mi>
              </mml:mrow>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula>, the corresponding RSS measurement can be expressed according to the following radio propagation path loss model in dB&#x2019;s [<xref ref-type="bibr" rid="B13-sensors-16-00722">13</xref>].
      <disp-formula id="FD10-sensors-16-00722">
        <label>(10)</label>
        <mml:math id="mm60" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi>L</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:msub>
                <mml:mi>L</mml:mi>
                <mml:mn>0</mml:mn>
              </mml:msub>
              <mml:mo>+</mml:mo>
              <mml:mn>10</mml:mn>
              <mml:mi>&#x3B3;</mml:mi>
              <mml:msub>
                <mml:mo form="prefix">log</mml:mo>
                <mml:mn>10</mml:mn>
              </mml:msub>
              <mml:mfrac>
                <mml:msub>
                  <mml:mi>&#x3C4;</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:msub>
                  <mml:mi>&#x3C4;</mml:mi>
                  <mml:mn>0</mml:mn>
                </mml:msub>
              </mml:mfrac>
              <mml:mo>+</mml:mo>
              <mml:msub>
                <mml:mi>&#x3BD;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      where <inline-formula>
        <mml:math id="mm61" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi>L</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:msub>
                <mml:mi>P</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msub>
              <mml:mo>-</mml:mo>
              <mml:msub>
                <mml:mi>P</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> is the path loss, <inline-formula>
        <mml:math id="mm62" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi>P</mml:mi>
              <mml:mi>T</mml:mi>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> is the transmission power, <inline-formula>
        <mml:math id="mm63" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi>L</mml:mi>
              <mml:mn>0</mml:mn>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> denotes the path loss value at the reference distance <inline-formula>
        <mml:math id="mm64" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi>&#x3C4;</mml:mi>
              <mml:mn>0</mml:mn>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula>, <italic>&#x3B3;</italic> is the path loss exponent, and <inline-formula>
        <mml:math id="mm65" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi>&#x3BD;</mml:mi>
              <mml:mrow>
                <mml:mi>i</mml:mi>
                <mml:mi>j</mml:mi>
              </mml:mrow>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> is a Gaussian random variable representing the log-normal shadowing effect, <inline-formula>
        <mml:math id="mm66" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi>&#x3BD;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>&#x223C;</mml:mo>
              <mml:mi mathvariant="script">N</mml:mi>
              <mml:mrow>
                <mml:mo stretchy="false">(</mml:mo>
                <mml:mn>0</mml:mn>
                <mml:mo>,</mml:mo>
                <mml:msubsup>
                  <mml:mi>&#x3C3;</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                  <mml:mn>2</mml:mn>
                </mml:msubsup>
                <mml:mo stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. The distance <inline-formula>
        <mml:math id="mm67" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi>&#x3C4;</mml:mi>
              <mml:mrow>
                <mml:mi>i</mml:mi>
                <mml:mi>j</mml:mi>
              </mml:mrow>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> can be computed through the RSS measurement by the maximum likelihood (ML) estimation. Then, the corresponding ML estimator <inline-formula>
        <mml:math id="mm68" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mover accent="true">
                <mml:mi>&#x3C4;</mml:mi>
                <mml:mo>^</mml:mo>
              </mml:mover>
              <mml:mrow>
                <mml:mi>i</mml:mi>
                <mml:mi>j</mml:mi>
              </mml:mrow>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> is given by [<xref ref-type="bibr" rid="B5-sensors-16-00722">5</xref>]
      <disp-formula id="FD11-sensors-16-00722">
        <label>(11)</label>
        <mml:math id="mm69" display="block">
          <mml:semantics>
            <mml:mtable displaystyle="true">
              <mml:mtr>
                <mml:mtd columnalign="right">
                  <mml:msub>
                    <mml:mover accent="true">
                      <mml:mi>&#x3C4;</mml:mi>
                      <mml:mo>&#x2DC;</mml:mo>
                    </mml:mover>
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mi>j</mml:mi>
                    </mml:mrow>
                  </mml:msub>
                </mml:mtd>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:mo>=</mml:mo>
                    <mml:mo form="prefix">arg</mml:mo>
                    <mml:munder>
                      <mml:mo movablelimits="true" form="prefix">min</mml:mo>
                      <mml:msub>
                        <mml:mi>&#x3C4;</mml:mi>
                        <mml:mrow>
                          <mml:mi>i</mml:mi>
                          <mml:mi>j</mml:mi>
                        </mml:mrow>
                      </mml:msub>
                    </mml:munder>
                    <mml:msup>
                      <mml:mfenced separators="" open="[" close="]">
                        <mml:mn>10</mml:mn>
                        <mml:mi>&#x3B3;</mml:mi>
                        <mml:msub>
                          <mml:mo form="prefix">log</mml:mo>
                          <mml:mn>10</mml:mn>
                        </mml:msub>
                        <mml:mfrac>
                          <mml:msub>
                            <mml:mi>&#x3C4;</mml:mi>
                            <mml:mrow>
                              <mml:mi>i</mml:mi>
                              <mml:mi>j</mml:mi>
                            </mml:mrow>
                          </mml:msub>
                          <mml:msub>
                            <mml:mi>&#x3C4;</mml:mi>
                            <mml:mn>0</mml:mn>
                          </mml:msub>
                        </mml:mfrac>
                        <mml:mo>-</mml:mo>
                        <mml:mrow>
                          <mml:mo  stretchy="false">(</mml:mo>
                          <mml:msub>
                            <mml:mi>L</mml:mi>
                            <mml:mrow>
                              <mml:mi>i</mml:mi>
                              <mml:mi>j</mml:mi>
                            </mml:mrow>
                          </mml:msub>
                          <mml:mo>-</mml:mo>
                          <mml:msub>
                            <mml:mi>L</mml:mi>
                            <mml:mn>0</mml:mn>
                          </mml:msub>
                          <mml:mo  stretchy="false">)</mml:mo>
                        </mml:mrow>
                      </mml:mfenced>
                      <mml:mn>2</mml:mn>
                    </mml:msup>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      <disp-formula id="FD12-sensors-16-00722">
        <label>(12)</label>
        <mml:math id="mm70" display="block">
          <mml:semantics>
            <mml:mtable displaystyle="true">
              <mml:mtr>
                <mml:mtd/>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:mo>=</mml:mo>
                    <mml:msub>
                      <mml:mi>&#x3C4;</mml:mi>
                      <mml:mn>0</mml:mn>
                    </mml:msub>
                    <mml:msup>
                      <mml:mn>10</mml:mn>
                      <mml:mrow>
                        <mml:mo  stretchy="false">(</mml:mo>
                        <mml:msub>
                          <mml:mi>L</mml:mi>
                          <mml:mrow>
                            <mml:mi>i</mml:mi>
                            <mml:mi>j</mml:mi>
                          </mml:mrow>
                        </mml:msub>
                        <mml:mo>-</mml:mo>
                        <mml:msub>
                          <mml:mi>L</mml:mi>
                          <mml:mn>0</mml:mn>
                        </mml:msub>
                        <mml:mo  stretchy="false">)</mml:mo>
                        <mml:mo>/</mml:mo>
                        <mml:mn>10</mml:mn>
                        <mml:mi>&#x3B3;</mml:mi>
                      </mml:mrow>
                    </mml:msup>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:semantics>
        </mml:math>
      </disp-formula></p>
      <p>Note that if we define <inline-formula>
        <mml:math id="mm71" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi>&#x3BE;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:mo form="prefix">exp</mml:mo>
              <mml:mfenced separators="" open="{" close="}">
                <mml:mfrac>
                  <mml:msub>
                    <mml:mi>&#x3BD;</mml:mi>
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mi>j</mml:mi>
                    </mml:mrow>
                  </mml:msub>
                  <mml:mrow>
                    <mml:mn>10</mml:mn>
                    <mml:msub>
                      <mml:mo form="prefix">log</mml:mo>
                      <mml:mn>10</mml:mn>
                    </mml:msub>
                    <mml:mi>e</mml:mi>
                  </mml:mrow>
                </mml:mfrac>
              </mml:mfenced>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, where <italic>e</italic> is the Euler&#x2019;s number, then <inline-formula>
        <mml:math id="mm72" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mn>10</mml:mn>
              <mml:msub>
                <mml:mo form="prefix">log</mml:mo>
                <mml:mn>10</mml:mn>
              </mml:msub>
              <mml:mi>&#x3BE;</mml:mi>
              <mml:mo>&#x223C;</mml:mo>
              <mml:mi mathvariant="script">N</mml:mi>
              <mml:mrow>
                <mml:mo stretchy="false">(</mml:mo>
                <mml:mn>0</mml:mn>
                <mml:mo>,</mml:mo>
                <mml:msubsup>
                  <mml:mi>&#x3C3;</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                  <mml:mn>2</mml:mn>
                </mml:msubsup>
                <mml:mo stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. The Equation (<xref ref-type="disp-formula" rid="FD12-sensors-16-00722">12</xref>) can be rewritten as
      <disp-formula id="FD13-sensors-16-00722">
        <label>(13)</label>
        <mml:math id="mm73" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mover accent="true">
                  <mml:mi>&#x3C4;</mml:mi>
                  <mml:mo>&#x2DC;</mml:mo>
                </mml:mover>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:msub>
                <mml:mi>&#x3C4;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:msubsup>
                <mml:mi>&#x3BE;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
                <mml:mrow>
                  <mml:mn>1</mml:mn>
                  <mml:mo>/</mml:mo>
                  <mml:mi>&#x3B3;</mml:mi>
                </mml:mrow>
              </mml:msubsup>
              <mml:mo>=</mml:mo>
              <mml:msub>
                <mml:mi>&#x3C4;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:msup>
                <mml:mfenced separators="" open="(" close=")">
                  <mml:mo form="prefix">exp</mml:mo>
                  <mml:mfenced separators="" open="{" close="}">
                    <mml:mfrac>
                      <mml:msub>
                        <mml:mi>&#x3BD;</mml:mi>
                        <mml:mrow>
                          <mml:mi>i</mml:mi>
                          <mml:mi>j</mml:mi>
                        </mml:mrow>
                      </mml:msub>
                      <mml:mrow>
                        <mml:mn>10</mml:mn>
                        <mml:msub>
                          <mml:mo form="prefix">log</mml:mo>
                          <mml:mn>10</mml:mn>
                        </mml:msub>
                        <mml:mi>e</mml:mi>
                      </mml:mrow>
                    </mml:mfrac>
                  </mml:mfenced>
                </mml:mfenced>
                <mml:mrow>
                  <mml:mn>1</mml:mn>
                  <mml:mo>/</mml:mo>
                  <mml:mi>&#x3B3;</mml:mi>
                </mml:mrow>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula></p>
      <p>By using the Gaussian moment generating function, we can derive
      <disp-formula id="FD14-sensors-16-00722">
        <label>(14)</label>
        <mml:math id="mm74" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="double-struck">E</mml:mi>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mover accent="true">
                    <mml:mi>&#x3C4;</mml:mi>
                    <mml:mo>&#x2DC;</mml:mo>
                  </mml:mover>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:msub>
                <mml:mi>&#x3C4;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo form="prefix">exp</mml:mo>
              <mml:mfenced separators="" open="{" close="}">
                <mml:mfrac>
                  <mml:msubsup>
                    <mml:mi>&#x3C3;</mml:mi>
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mi>j</mml:mi>
                    </mml:mrow>
                    <mml:mn>2</mml:mn>
                  </mml:msubsup>
                  <mml:mrow>
                    <mml:mn>10</mml:mn>
                    <mml:msup>
                      <mml:mi>&#x3B3;</mml:mi>
                      <mml:mn>2</mml:mn>
                    </mml:msup>
                    <mml:msubsup>
                      <mml:mo form="prefix">log</mml:mo>
                      <mml:mrow>
                        <mml:mn>10</mml:mn>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msubsup>
                    <mml:mi>e</mml:mi>
                  </mml:mrow>
                </mml:mfrac>
              </mml:mfenced>
              <mml:mo>,</mml:mo>
              <mml:mo form="prefix">Var</mml:mo>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mover accent="true">
                    <mml:mi>&#x3C4;</mml:mi>
                    <mml:mo>&#x2DC;</mml:mo>
                  </mml:mover>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:msubsup>
                <mml:mi>&#x3C4;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
                <mml:mn>2</mml:mn>
              </mml:msubsup>
              <mml:mfenced separators="" open="[" close="]">
                <mml:mo form="prefix">exp</mml:mo>
                <mml:mfenced separators="" open="{" close="}">
                  <mml:mfrac>
                    <mml:msubsup>
                      <mml:mi>&#x3C3;</mml:mi>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mi>j</mml:mi>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msubsup>
                    <mml:mrow>
                      <mml:mn>50</mml:mn>
                      <mml:msup>
                        <mml:mi>&#x3B3;</mml:mi>
                        <mml:mn>2</mml:mn>
                      </mml:msup>
                      <mml:msubsup>
                        <mml:mo form="prefix">log</mml:mo>
                        <mml:mrow>
                          <mml:mn>10</mml:mn>
                        </mml:mrow>
                        <mml:mn>2</mml:mn>
                      </mml:msubsup>
                      <mml:mi>e</mml:mi>
                    </mml:mrow>
                  </mml:mfrac>
                </mml:mfenced>
                <mml:mo>-</mml:mo>
                <mml:mo form="prefix">exp</mml:mo>
                <mml:mfenced separators="" open="{" close="}">
                  <mml:mfrac>
                    <mml:msubsup>
                      <mml:mi>&#x3C3;</mml:mi>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mi>j</mml:mi>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msubsup>
                    <mml:mrow>
                      <mml:mn>100</mml:mn>
                      <mml:msup>
                        <mml:mi>&#x3B3;</mml:mi>
                        <mml:mn>2</mml:mn>
                      </mml:msup>
                      <mml:msubsup>
                        <mml:mo form="prefix">log</mml:mo>
                        <mml:mrow>
                          <mml:mn>10</mml:mn>
                        </mml:mrow>
                        <mml:mn>2</mml:mn>
                      </mml:msubsup>
                      <mml:mi>e</mml:mi>
                    </mml:mrow>
                  </mml:mfrac>
                </mml:mfenced>
              </mml:mfenced>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      which shows that the estimator is biased. In order to obtain the unbiased estimator, we let <inline-formula>
        <mml:math id="mm75" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mover accent="true">
                  <mml:mi>&#x3C4;</mml:mi>
                  <mml:mo>^</mml:mo>
                </mml:mover>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:mfrac>
                <mml:msub>
                  <mml:mover accent="true">
                    <mml:mi>&#x3C4;</mml:mi>
                    <mml:mo>&#x2DC;</mml:mo>
                  </mml:mover>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mi>&#x3D6;</mml:mi>
              </mml:mfrac>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> where <inline-formula>
        <mml:math id="mm76" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>&#x3D6;</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mo form="prefix">exp</mml:mo>
              <mml:mfenced separators="" open="{" close="}">
                <mml:mfrac>
                  <mml:msubsup>
                    <mml:mi>&#x3C3;</mml:mi>
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mi>j</mml:mi>
                    </mml:mrow>
                    <mml:mn>2</mml:mn>
                  </mml:msubsup>
                  <mml:mrow>
                    <mml:mn>200</mml:mn>
                    <mml:msup>
                      <mml:mi>&#x3B3;</mml:mi>
                      <mml:mn>2</mml:mn>
                    </mml:msup>
                    <mml:msubsup>
                      <mml:mo form="prefix">log</mml:mo>
                      <mml:mrow>
                        <mml:mn>10</mml:mn>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msubsup>
                    <mml:mi>e</mml:mi>
                  </mml:mrow>
                </mml:mfrac>
              </mml:mfenced>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, which yields the following variance of <inline-formula>
        <mml:math id="mm77" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">Var</mml:mo>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mover accent="true">
                    <mml:mi>&#x3C4;</mml:mi>
                    <mml:mo>^</mml:mo>
                  </mml:mover>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:msubsup>
                <mml:mi>&#x3C4;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
                <mml:mn>2</mml:mn>
              </mml:msubsup>
              <mml:mfenced separators="" open="[" close="]">
                <mml:mo form="prefix">exp</mml:mo>
                <mml:mfenced separators="" open="{" close="}">
                  <mml:mfrac>
                    <mml:msubsup>
                      <mml:mi>&#x3C3;</mml:mi>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mi>j</mml:mi>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msubsup>
                    <mml:mrow>
                      <mml:mn>100</mml:mn>
                      <mml:msup>
                        <mml:mi>&#x3B3;</mml:mi>
                        <mml:mn>2</mml:mn>
                      </mml:msup>
                      <mml:msubsup>
                        <mml:mo form="prefix">log</mml:mo>
                        <mml:mrow>
                          <mml:mn>10</mml:mn>
                        </mml:mrow>
                        <mml:mn>2</mml:mn>
                      </mml:msubsup>
                      <mml:mi>e</mml:mi>
                    </mml:mrow>
                  </mml:mfrac>
                </mml:mfenced>
                <mml:mo>-</mml:mo>
                <mml:mn>1</mml:mn>
              </mml:mfenced>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>.</p>
      <p>After obtaining the estimated distance <inline-formula>
        <mml:math id="mm78" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mover accent="true">
                <mml:mi>&#x3C4;</mml:mi>
                <mml:mo>^</mml:mo>
              </mml:mover>
              <mml:mrow>
                <mml:mi>i</mml:mi>
                <mml:mi>j</mml:mi>
              </mml:mrow>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula>, we can apply the SDP estimator [<xref ref-type="bibr" rid="B6-sensors-16-00722">6</xref>] or its relaxation [<xref ref-type="bibr" rid="B5-sensors-16-00722">5</xref>,<xref ref-type="bibr" rid="B14-sensors-16-00722">14</xref>] to reconstruct the distance matrix <inline-formula>
        <mml:math id="mm79" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">D</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula> from the RSS measurements. By partitioning, the <inline-formula>
        <mml:math id="mm80" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>n</mml:mi>
              <mml:mo>&#xD7;</mml:mo>
              <mml:mi>n</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> Euclidean squared distance matrix can be expressed as follows.
      <disp-formula id="FD15-sensors-16-00722">
        <label>(15)</label>
        <mml:math id="mm81" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">D</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mfenced open="[" close="]">
                <mml:mtable>
                  <mml:mtr>
                    <mml:mtd>
                      <mml:msub>
                        <mml:mi mathvariant="bold">D</mml:mi>
                        <mml:mn>11</mml:mn>
                      </mml:msub>
                    </mml:mtd>
                    <mml:mtd>
                      <mml:msub>
                        <mml:mi mathvariant="bold">D</mml:mi>
                        <mml:mn>12</mml:mn>
                      </mml:msub>
                    </mml:mtd>
                  </mml:mtr>
                  <mml:mtr>
                    <mml:mtd>
                      <mml:msub>
                        <mml:mi mathvariant="bold">D</mml:mi>
                        <mml:mn>21</mml:mn>
                      </mml:msub>
                    </mml:mtd>
                    <mml:mtd>
                      <mml:msub>
                        <mml:mi mathvariant="bold">D</mml:mi>
                        <mml:mn>22</mml:mn>
                      </mml:msub>
                    </mml:mtd>
                  </mml:mtr>
                </mml:mtable>
              </mml:mfenced>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      where <inline-formula>
        <mml:math id="mm82" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi mathvariant="bold">D</mml:mi>
              <mml:mn>11</mml:mn>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> is the <inline-formula>
        <mml:math id="mm83" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo  stretchy="false">(</mml:mo>
              <mml:mi>n</mml:mi>
              <mml:mo>-</mml:mo>
              <mml:mi>m</mml:mi>
              <mml:mo  stretchy="false">)</mml:mo>
              <mml:mo>&#xD7;</mml:mo>
              <mml:mo  stretchy="false">(</mml:mo>
              <mml:mi>n</mml:mi>
              <mml:mo>-</mml:mo>
              <mml:mi>m</mml:mi>
              <mml:mo  stretchy="false">)</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> distance sub-matrix between the unknown locations, <inline-formula>
        <mml:math id="mm84" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mn>21</mml:mn>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:msubsup>
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mrow>
                  <mml:mn>12</mml:mn>
                </mml:mrow>
                <mml:mi>T</mml:mi>
              </mml:msubsup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> is the distance sub-matrix between the anchor locations and the unknown locations, and <inline-formula>
        <mml:math id="mm85" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi mathvariant="bold">D</mml:mi>
              <mml:mn>22</mml:mn>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> is the distance sub-matrix between the anchor locations.</p>
      <p>However, since at any time an unknown node <italic>i</italic> is only in the communication range of small subset of the anchor nodes, the matrix of RSS measurements is partially known. Thus, the matrix <inline-formula>
        <mml:math id="mm86" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">D</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula> in Equation (<xref ref-type="disp-formula" rid="FD8-sensors-16-00722">8</xref>) is incomplete and is affected by noises, <italic>i.e.</italic>, <inline-formula>
        <mml:math id="mm87" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mover accent="true">
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mo>&#x2DC;</mml:mo>
              </mml:mover>
              <mml:mo>=</mml:mo>
              <mml:mi mathvariant="bold">D</mml:mi>
              <mml:mo>+</mml:mo>
              <mml:mi mathvariant="bold">N</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. Our goal is to reconstruct the complete distance matrix <inline-formula>
        <mml:math id="mm88" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">D</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula> from the RSS measurements. From this matrix, we can recover the unknown node locations. The problem formulation is briefly described as follows. Given <inline-formula>
        <mml:math id="mm89" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">A</mml:mi>
              <mml:mo>&#x2208;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="double-struck">R</mml:mi>
                <mml:mrow>
                  <mml:mi>m</mml:mi>
                  <mml:mo>&#xD7;</mml:mo>
                  <mml:mi>r</mml:mi>
                </mml:mrow>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> and <inline-formula>
        <mml:math id="mm90" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>n</mml:mi>
              <mml:mo>&#xD7;</mml:mo>
              <mml:mi>n</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> distance matrix <inline-formula>
        <mml:math id="mm91" display="block">
          <mml:semantics>
            <mml:mover accent="true">
              <mml:mi mathvariant="bold">D</mml:mi>
              <mml:mo>&#x2DC;</mml:mo>
            </mml:mover>
          </mml:semantics>
        </mml:math>
      </inline-formula> with corresponding adjacency matrix <inline-formula>
        <mml:math id="mm92" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">H</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula>, we need to solve
      <disp-formula id="FD16-sensors-16-00722">
        <label>(16)</label>
        <mml:math id="mm93" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:munder>
                <mml:mo movablelimits="true" form="prefix">min</mml:mo>
                <mml:mrow>
                  <mml:mi mathvariant="bold">D</mml:mi>
                  <mml:mo>&#x2208;</mml:mo>
                  <mml:mo form="prefix">EDM</mml:mo>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:mi>n</mml:mi>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
              </mml:munder>
              <mml:mrow>
                <mml:mo>|</mml:mo>
                <mml:mo>|</mml:mo>
                <mml:mi mathvariant="bold">H</mml:mi>
              </mml:mrow>
              <mml:mo>&#x2218;</mml:mo>
              <mml:mrow>
                <mml:mo stretchy="false">(</mml:mo>
                <mml:mover accent="true">
                  <mml:mi mathvariant="bold">D</mml:mi>
                  <mml:mo>&#x2DC;</mml:mo>
                </mml:mover>
                <mml:mo>-</mml:mo>
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mo stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:msubsup>
                <mml:mrow>
                  <mml:mo>|</mml:mo>
                  <mml:mo>|</mml:mo>
                </mml:mrow>
                <mml:mi>F</mml:mi>
                <mml:mn>2</mml:mn>
              </mml:msubsup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula></p>
    </sec>
    <sec id="sec3-sensors-16-00722">
      <title>3. Main Results</title>
      <p>The problem in Equation (<xref ref-type="disp-formula" rid="FD16-sensors-16-00722">16</xref>) cannot be solved easily due to its non-convex nature and high computational complexity. Then, we try to reformulate it into another form without leaving the minimum. We suppose that <inline-formula>
        <mml:math id="mm94" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mo>&#x2208;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="double-struck">R</mml:mi>
                <mml:mrow>
                  <mml:mi>n</mml:mi>
                  <mml:mo>&#xD7;</mml:mo>
                  <mml:mi>r</mml:mi>
                </mml:mrow>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> satisfies <inline-formula>
        <mml:math id="mm95" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">Pe</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn mathvariant="bold">0</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> (centroid) and <inline-formula>
        <mml:math id="mm96" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">H</mml:mi>
              <mml:mo>&#x2218;</mml:mo>
              <mml:msup>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
                <mml:mi>T</mml:mi>
              </mml:msup>
              <mml:mo>=</mml:mo>
              <mml:mi mathvariant="bold">H</mml:mi>
              <mml:mo>&#x2218;</mml:mo>
              <mml:mi mathvariant="bold">D</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. Based on the fact that any rank-<italic>r</italic> positive semidefinite matrix admits a factorization <inline-formula>
        <mml:math id="mm97" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">Y</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:msup>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> [<xref ref-type="bibr" rid="B11-sensors-16-00722">11</xref>], we rewrite Equation (<xref ref-type="disp-formula" rid="FD16-sensors-16-00722">16</xref>) as
      <disp-formula id="FD17-sensors-16-00722">
        <label>(17)</label>
        <mml:math id="mm98" display="block">
          <mml:semantics>
            <mml:mtable displaystyle="true">
              <mml:mtr>
                <mml:mtd/>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:munder>
                      <mml:mo movablelimits="true" form="prefix">min</mml:mo>
                      <mml:mrow>
                        <mml:mi mathvariant="bold">D</mml:mi>
                        <mml:mo>&#x2208;</mml:mo>
                        <mml:mo form="prefix">EDM</mml:mo>
                        <mml:mo  stretchy="false">(</mml:mo>
                        <mml:mi>n</mml:mi>
                        <mml:mo  stretchy="false">)</mml:mo>
                      </mml:mrow>
                    </mml:munder>
                    <mml:mrow>
                      <mml:mspace width="3.33333pt"/>
                      <mml:mo>|</mml:mo>
                      <mml:mo>|</mml:mo>
                      <mml:mi mathvariant="bold">H</mml:mi>
                    </mml:mrow>
                    <mml:mo>&#x2218;</mml:mo>
                    <mml:mrow>
                      <mml:mo stretchy="false">(</mml:mo>
                      <mml:mover accent="true">
                        <mml:mi mathvariant="bold">D</mml:mi>
                        <mml:mo>&#x2DC;</mml:mo>
                      </mml:mover>
                      <mml:mo>-</mml:mo>
                      <mml:mi>&#x3BA;</mml:mi>
                      <mml:mrow>
                        <mml:mo  stretchy="false">(</mml:mo>
                        <mml:mi mathvariant="bold">P</mml:mi>
                        <mml:msup>
                          <mml:mi mathvariant="bold">P</mml:mi>
                          <mml:mi>T</mml:mi>
                        </mml:msup>
                        <mml:mo  stretchy="false">)</mml:mo>
                      </mml:mrow>
                      <mml:mo stretchy="false">)</mml:mo>
                    </mml:mrow>
                    <mml:msubsup>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mo>|</mml:mo>
                      </mml:mrow>
                      <mml:mi>F</mml:mi>
                      <mml:mn>2</mml:mn>
                    </mml:msubsup>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd/>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:mtext>subject</mml:mtext>
                    <mml:mspace width="4.pt"/>
                    <mml:mtext>to</mml:mtext>
                    <mml:mspace width="3.33333pt"/>
                    <mml:mi mathvariant="bold">P</mml:mi>
                    <mml:mo>=</mml:mo>
                    <mml:mfenced open="[" close="]">
                      <mml:mtable>
                        <mml:mtr>
                          <mml:mtd>
                            <mml:mi mathvariant="bold">X</mml:mi>
                          </mml:mtd>
                        </mml:mtr>
                        <mml:mtr>
                          <mml:mtd>
                            <mml:mi mathvariant="bold">A</mml:mi>
                          </mml:mtd>
                        </mml:mtr>
                      </mml:mtable>
                    </mml:mfenced>
                    <mml:mo>&#x2208;</mml:mo>
                    <mml:msup>
                      <mml:mi mathvariant="double-struck">R</mml:mi>
                      <mml:mrow>
                        <mml:mi>n</mml:mi>
                        <mml:mo>&#xD7;</mml:mo>
                        <mml:mi>r</mml:mi>
                      </mml:mrow>
                    </mml:msup>
                    <mml:mo>,</mml:mo>
                    <mml:mi mathvariant="bold">Pe</mml:mi>
                    <mml:mo>=</mml:mo>
                    <mml:mn mathvariant="bold">0</mml:mn>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:semantics>
        </mml:math>
      </disp-formula></p>
      <p>For simplicity, let <inline-formula>
        <mml:math id="mm99" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">p</mml:mi>
                <mml:mi>i</mml:mi>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:msubsup>
                  <mml:mi>p</mml:mi>
                  <mml:mi>i</mml:mi>
                  <mml:mrow>
                    <mml:mo  stretchy="false">(</mml:mo>
                    <mml:mn>1</mml:mn>
                    <mml:mo  stretchy="false">)</mml:mo>
                  </mml:mrow>
                </mml:msubsup>
                <mml:mo>,</mml:mo>
                <mml:mo>&#x22EF;</mml:mo>
                <mml:mo>,</mml:mo>
                <mml:msubsup>
                  <mml:mi>p</mml:mi>
                  <mml:mi>i</mml:mi>
                  <mml:mrow>
                    <mml:mo  stretchy="false">(</mml:mo>
                    <mml:mi>r</mml:mi>
                    <mml:mo  stretchy="false">)</mml:mo>
                  </mml:mrow>
                </mml:msubsup>
                <mml:mo>]</mml:mo>
              </mml:mrow>
              <mml:mo>,</mml:mo>
              <mml:mi mathvariant="bold">D</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:msub>
                  <mml:mi>d</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>]</mml:mo>
              </mml:mrow>
              <mml:mo>,</mml:mo>
              <mml:mi mathvariant="bold">H</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:msub>
                  <mml:mi>h</mml:mi>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>]</mml:mo>
              </mml:mrow>
              <mml:mo>,</mml:mo>
              <mml:mover accent="true">
                <mml:mi mathvariant="bold">D</mml:mi>
                <mml:mo>&#x2DC;</mml:mo>
              </mml:mover>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:msub>
                  <mml:mover accent="true">
                    <mml:mi>d</mml:mi>
                    <mml:mo>&#x2DC;</mml:mo>
                  </mml:mover>
                  <mml:mrow>
                    <mml:mi>i</mml:mi>
                    <mml:mi>j</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>]</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, and <inline-formula>
        <mml:math id="mm100" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">Y</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mo>[</mml:mo>
              <mml:msub>
                <mml:mi>y</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>]</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. Therefore, we denote the objective function as
      <disp-formula id="FD18-sensors-16-00722">
        <label>(18)</label>
        <mml:math id="mm101" display="block">
          <mml:semantics>
            <mml:mtable displaystyle="true">
              <mml:mtr>
                <mml:mtd columnalign="right">
                  <mml:mrow>
                    <mml:mi>f</mml:mi>
                    <mml:mo  stretchy="false">(</mml:mo>
                    <mml:mi mathvariant="bold">P</mml:mi>
                    <mml:mo  stretchy="false">)</mml:mo>
                  </mml:mrow>
                </mml:mtd>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:mo>=</mml:mo>
                    <mml:mrow>
                      <mml:mo>|</mml:mo>
                      <mml:mo>|</mml:mo>
                      <mml:mi mathvariant="bold">H</mml:mi>
                    </mml:mrow>
                    <mml:mo>&#x2218;</mml:mo>
                    <mml:mrow>
                      <mml:mo stretchy="false">(</mml:mo>
                      <mml:mover accent="true">
                        <mml:mi mathvariant="bold">D</mml:mi>
                        <mml:mo>&#x2DC;</mml:mo>
                      </mml:mover>
                      <mml:mo>-</mml:mo>
                      <mml:mi>&#x3BA;</mml:mi>
                      <mml:mrow>
                        <mml:mo  stretchy="false">(</mml:mo>
                        <mml:mi mathvariant="bold">P</mml:mi>
                        <mml:msup>
                          <mml:mi mathvariant="bold">P</mml:mi>
                          <mml:mi>T</mml:mi>
                        </mml:msup>
                        <mml:mo  stretchy="false">)</mml:mo>
                      </mml:mrow>
                      <mml:mo stretchy="false">)</mml:mo>
                    </mml:mrow>
                    <mml:msubsup>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mo>|</mml:mo>
                      </mml:mrow>
                      <mml:mi>F</mml:mi>
                      <mml:mn>2</mml:mn>
                    </mml:msubsup>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd/>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:mo>=</mml:mo>
                    <mml:munderover>
                      <mml:mo>&#x2211;</mml:mo>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mo>=</mml:mo>
                        <mml:mn>1</mml:mn>
                      </mml:mrow>
                      <mml:mi>n</mml:mi>
                    </mml:munderover>
                    <mml:munderover>
                      <mml:mo>&#x2211;</mml:mo>
                      <mml:mrow>
                        <mml:mi>j</mml:mi>
                        <mml:mo>=</mml:mo>
                        <mml:mn>1</mml:mn>
                      </mml:mrow>
                      <mml:mi>n</mml:mi>
                    </mml:munderover>
                    <mml:msub>
                      <mml:mi>h</mml:mi>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mi>j</mml:mi>
                      </mml:mrow>
                    </mml:msub>
                    <mml:msup>
                      <mml:mrow>
                        <mml:mo stretchy="false">(</mml:mo>
                        <mml:msub>
                          <mml:mover accent="true">
                            <mml:mi>d</mml:mi>
                            <mml:mo>&#x2DC;</mml:mo>
                          </mml:mover>
                          <mml:mrow>
                            <mml:mi>i</mml:mi>
                            <mml:mi>j</mml:mi>
                          </mml:mrow>
                        </mml:msub>
                        <mml:mo>-</mml:mo>
                        <mml:msub>
                          <mml:mi>d</mml:mi>
                          <mml:mrow>
                            <mml:mi>i</mml:mi>
                            <mml:mi>j</mml:mi>
                          </mml:mrow>
                        </mml:msub>
                        <mml:mo stretchy="false">)</mml:mo>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msup>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd/>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:mo>=</mml:mo>
                    <mml:munderover>
                      <mml:mo>&#x2211;</mml:mo>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mo>=</mml:mo>
                        <mml:mn>1</mml:mn>
                      </mml:mrow>
                      <mml:mi>n</mml:mi>
                    </mml:munderover>
                    <mml:munderover>
                      <mml:mo>&#x2211;</mml:mo>
                      <mml:mrow>
                        <mml:mi>j</mml:mi>
                        <mml:mo>=</mml:mo>
                        <mml:mn>1</mml:mn>
                      </mml:mrow>
                      <mml:mi>n</mml:mi>
                    </mml:munderover>
                    <mml:msub>
                      <mml:mi>h</mml:mi>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mi>j</mml:mi>
                      </mml:mrow>
                    </mml:msub>
                    <mml:mrow>
                      <mml:mo stretchy="false">(</mml:mo>
                    </mml:mrow>
                    <mml:msub>
                      <mml:mover accent="true">
                        <mml:mi>d</mml:mi>
                        <mml:mo>&#x2DC;</mml:mo>
                      </mml:mover>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mi>j</mml:mi>
                      </mml:mrow>
                    </mml:msub>
                    <mml:mo>-</mml:mo>
                    <mml:mrow>
                      <mml:mo>|</mml:mo>
                      <mml:mo>|</mml:mo>
                    </mml:mrow>
                    <mml:msub>
                      <mml:mi mathvariant="bold">p</mml:mi>
                      <mml:mi>i</mml:mi>
                    </mml:msub>
                    <mml:mo>-</mml:mo>
                    <mml:msub>
                      <mml:mi mathvariant="bold">p</mml:mi>
                      <mml:mi>j</mml:mi>
                    </mml:msub>
                    <mml:msup>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mo>|</mml:mo>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msup>
                    <mml:msup>
                      <mml:mrow>
                        <mml:mo stretchy="false">)</mml:mo>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msup>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:semantics>
        </mml:math>
      </disp-formula></p>
      <p>Following Equation (<xref ref-type="disp-formula" rid="FD5-sensors-16-00722">5</xref>), we have
      <disp-formula id="FD19-sensors-16-00722">
        <label>(19)</label>
        <mml:math id="mm102" display="block">
          <mml:semantics>
            <mml:mtable displaystyle="true">
              <mml:mtr>
                <mml:mtd columnalign="right">
                  <mml:msub>
                    <mml:mi>d</mml:mi>
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mi>j</mml:mi>
                    </mml:mrow>
                  </mml:msub>
                </mml:mtd>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:mo>=</mml:mo>
                    <mml:msub>
                      <mml:mi>y</mml:mi>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mi>i</mml:mi>
                      </mml:mrow>
                    </mml:msub>
                    <mml:mo>-</mml:mo>
                    <mml:mn>2</mml:mn>
                    <mml:msub>
                      <mml:mi>y</mml:mi>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mi>j</mml:mi>
                      </mml:mrow>
                    </mml:msub>
                    <mml:mo>+</mml:mo>
                    <mml:msub>
                      <mml:mi>y</mml:mi>
                      <mml:mrow>
                        <mml:mi>j</mml:mi>
                        <mml:mi>j</mml:mi>
                      </mml:mrow>
                    </mml:msub>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd/>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:mo>=</mml:mo>
                    <mml:munderover>
                      <mml:mo>&#x2211;</mml:mo>
                      <mml:mrow>
                        <mml:mi>k</mml:mi>
                        <mml:mo>=</mml:mo>
                        <mml:mn>1</mml:mn>
                      </mml:mrow>
                      <mml:mi>r</mml:mi>
                    </mml:munderover>
                    <mml:msup>
                      <mml:mrow>
                        <mml:mo stretchy="false">(</mml:mo>
                        <mml:msubsup>
                          <mml:mi>p</mml:mi>
                          <mml:mi>i</mml:mi>
                          <mml:mrow>
                            <mml:mo  stretchy="false">(</mml:mo>
                            <mml:mi>k</mml:mi>
                            <mml:mo  stretchy="false">)</mml:mo>
                          </mml:mrow>
                        </mml:msubsup>
                        <mml:mo stretchy="false">)</mml:mo>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msup>
                    <mml:mo>+</mml:mo>
                    <mml:munderover>
                      <mml:mo>&#x2211;</mml:mo>
                      <mml:mrow>
                        <mml:mi>k</mml:mi>
                        <mml:mo>=</mml:mo>
                        <mml:mn>1</mml:mn>
                      </mml:mrow>
                      <mml:mi>r</mml:mi>
                    </mml:munderover>
                    <mml:msup>
                      <mml:mrow>
                        <mml:mo stretchy="false">(</mml:mo>
                        <mml:msubsup>
                          <mml:mi>p</mml:mi>
                          <mml:mi>j</mml:mi>
                          <mml:mrow>
                            <mml:mo  stretchy="false">(</mml:mo>
                            <mml:mi>k</mml:mi>
                            <mml:mo  stretchy="false">)</mml:mo>
                          </mml:mrow>
                        </mml:msubsup>
                        <mml:mo stretchy="false">)</mml:mo>
                      </mml:mrow>
                      <mml:mn>2</mml:mn>
                    </mml:msup>
                    <mml:mo>-</mml:mo>
                    <mml:mn>2</mml:mn>
                    <mml:munderover>
                      <mml:mo>&#x2211;</mml:mo>
                      <mml:mrow>
                        <mml:mi>k</mml:mi>
                        <mml:mo>=</mml:mo>
                        <mml:mn>1</mml:mn>
                      </mml:mrow>
                      <mml:mi>r</mml:mi>
                    </mml:munderover>
                    <mml:msubsup>
                      <mml:mi>p</mml:mi>
                      <mml:mi>i</mml:mi>
                      <mml:mrow>
                        <mml:mo  stretchy="false">(</mml:mo>
                        <mml:mi>k</mml:mi>
                        <mml:mo  stretchy="false">)</mml:mo>
                      </mml:mrow>
                    </mml:msubsup>
                    <mml:msubsup>
                      <mml:mi>p</mml:mi>
                      <mml:mi>j</mml:mi>
                      <mml:mrow>
                        <mml:mo  stretchy="false">(</mml:mo>
                        <mml:mi>k</mml:mi>
                        <mml:mo  stretchy="false">)</mml:mo>
                      </mml:mrow>
                    </mml:msubsup>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      where <inline-formula>
        <mml:math id="mm103" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>i</mml:mi>
              <mml:mo>,</mml:mo>
              <mml:mi>j</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn>1</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:mo>&#x22EF;</mml:mo>
              <mml:mo>,</mml:mo>
              <mml:mi>n</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. This problem is now reformulated as an constrained optimization for the cost function Equation (<xref ref-type="disp-formula" rid="FD18-sensors-16-00722">18</xref>), which can be solved efficiently by using the Newton&#x2019;s method [<xref ref-type="bibr" rid="B15-sensors-16-00722">15</xref>,<xref ref-type="bibr" rid="B16-sensors-16-00722">16</xref>,<xref ref-type="bibr" rid="B17-sensors-16-00722">17</xref>]. One of the motivations behind this method for optimization is to describe it as a sequence of second-order Taylor expansions and minimization.
      <disp-formula id="FD20-sensors-16-00722">
        <label>(20)</label>
        <mml:math id="mm104" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>f</mml:mi>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:mo>&#x2248;</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mi>k</mml:mi>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:mo>+</mml:mo>
              <mml:mo form="prefix">grad</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:msup>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:msup>
                    <mml:mi mathvariant="bold">P</mml:mi>
                    <mml:mrow>
                      <mml:mo  stretchy="false">(</mml:mo>
                      <mml:mi>k</mml:mi>
                      <mml:mo  stretchy="false">)</mml:mo>
                    </mml:mrow>
                  </mml:msup>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
                <mml:mi>T</mml:mi>
              </mml:msup>
              <mml:mi>&#x3BE;</mml:mi>
              <mml:mo>+</mml:mo>
              <mml:mfrac>
                <mml:mn>1</mml:mn>
                <mml:mn>2</mml:mn>
              </mml:mfrac>
              <mml:msup>
                <mml:mi>&#x3BE;</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msup>
              <mml:mo form="prefix">Hess</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mi>k</mml:mi>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:mi>&#x3BE;</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      where <inline-formula>
        <mml:math id="mm105" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>&#x3BE;</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mo>-</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. The iteration that computes an approximate solution to the system of equations <inline-formula>
        <mml:math id="mm106" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">grad</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mo  stretchy="false">(</mml:mo>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mo  stretchy="false">)</mml:mo>
              <mml:mo>=</mml:mo>
              <mml:mn mathvariant="bold">0</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, is updated as
      <disp-formula id="FD21-sensors-16-00722">
        <label>(21)</label>
        <mml:math id="mm107" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mrow>
                  <mml:mi>k</mml:mi>
                  <mml:mo>+</mml:mo>
                  <mml:mn>1</mml:mn>
                </mml:mrow>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:mo>-</mml:mo>
              <mml:msup>
                <mml:mrow>
                  <mml:mo>[</mml:mo>
                  <mml:mo form="prefix">Hess</mml:mo>
                  <mml:mi>f</mml:mi>
                  <mml:mrow>
                    <mml:mo  stretchy="false">(</mml:mo>
                    <mml:msub>
                      <mml:mi mathvariant="bold">P</mml:mi>
                      <mml:mi>k</mml:mi>
                    </mml:msub>
                    <mml:mo  stretchy="false">)</mml:mo>
                  </mml:mrow>
                  <mml:mo>]</mml:mo>
                </mml:mrow>
                <mml:mrow>
                  <mml:mo>-</mml:mo>
                  <mml:mn>1</mml:mn>
                </mml:mrow>
              </mml:msup>
              <mml:mo form="prefix">grad</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mi>k</mml:mi>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula></p>
      <p>In practice, one does not compute <inline-formula>
        <mml:math id="mm108" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mrow>
                <mml:mi>k</mml:mi>
                <mml:mo>+</mml:mo>
                <mml:mn>1</mml:mn>
              </mml:mrow>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> by explicitly computing <inline-formula>
        <mml:math id="mm109" display="block">
          <mml:semantics>
            <mml:msup>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:mo form="prefix">Hess</mml:mo>
                <mml:mi>f</mml:mi>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:msub>
                    <mml:mi mathvariant="bold">P</mml:mi>
                    <mml:mi>k</mml:mi>
                  </mml:msub>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
                <mml:mo>]</mml:mo>
              </mml:mrow>
              <mml:mrow>
                <mml:mo>-</mml:mo>
                <mml:mn>1</mml:mn>
              </mml:mrow>
            </mml:msup>
          </mml:semantics>
        </mml:math>
      </inline-formula> and then multiplying by <inline-formula>
        <mml:math id="mm110" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">grad</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mo  stretchy="false">(</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:mo  stretchy="false">)</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, since it is computationally inefficient. Instead, it is more practical to solve the system of linear equations
      <disp-formula id="FD22-sensors-16-00722">
        <label>(22)</label>
        <mml:math id="mm111" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">Hess</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mi>k</mml:mi>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:msub>
                <mml:mi>&#x3BE;</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:mo>-</mml:mo>
              <mml:mo form="prefix">grad</mml:mo>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mi>k</mml:mi>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      for unknown <inline-formula>
        <mml:math id="mm112" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi>&#x3BE;</mml:mi>
              <mml:mi>k</mml:mi>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula>. There are also many approaches such as matrix decompositions or other algebra techniques [<xref ref-type="bibr" rid="B18-sensors-16-00722">18</xref>] in calculating <inline-formula>
        <mml:math id="mm113" display="block">
          <mml:semantics>
            <mml:msup>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:mo form="prefix">Hess</mml:mo>
                <mml:mi>f</mml:mi>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:msub>
                    <mml:mi mathvariant="bold">P</mml:mi>
                    <mml:mi>k</mml:mi>
                  </mml:msub>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
                <mml:mo>]</mml:mo>
              </mml:mrow>
              <mml:mrow>
                <mml:mo>-</mml:mo>
                <mml:mn>1</mml:mn>
              </mml:mrow>
            </mml:msup>
          </mml:semantics>
        </mml:math>
      </inline-formula> to reduce its complexity when computing matrix operators. In general, the Newton&#x2019;s method will find the minimum in one iteration and has extremely fast convergence, if <inline-formula>
        <mml:math id="mm114" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">Hess</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mo  stretchy="false">(</mml:mo>
              <mml:mo>&#xB7;</mml:mo>
              <mml:mo  stretchy="false">)</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> is positive definite at the minimum and the initial guess for <inline-formula>
        <mml:math id="mm115" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">P</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula> is close enough to this point. However, in some cases it may return any critical points of <italic>f</italic>, that is, minima, maxima, or saddle points. To avoid these situations, we make some modifications to the Newton&#x2019;s method, so that it finds the critical points which are actually the minima.</p>
      <p>For search direction, we perform a line search, <italic>i.e.</italic>, for each iteration we solve Equation (<xref ref-type="disp-formula" rid="FD22-sensors-16-00722">22</xref>) and update
      <disp-formula id="FD23-sensors-16-00722">
        <label>(23)</label>
        <mml:math id="mm116" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mrow>
                  <mml:mi>k</mml:mi>
                  <mml:mo>+</mml:mo>
                  <mml:mn>1</mml:mn>
                </mml:mrow>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:mo>+</mml:mo>
              <mml:mi>t</mml:mi>
              <mml:msub>
                <mml:mi>&#x3BE;</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      where <italic>t</italic> is small enough to get fast convergence. It can be <inline-formula>
        <mml:math id="mm117" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mn>1</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:mfrac>
                <mml:mn>1</mml:mn>
                <mml:mn>2</mml:mn>
              </mml:mfrac>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> or <inline-formula>
        <mml:math id="mm118" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msup>
                <mml:mn>2</mml:mn>
                <mml:mrow>
                  <mml:mo>-</mml:mo>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msup>
              <mml:mo>,</mml:mo>
              <mml:mi>j</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn>0</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:mn>1</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:mn>2</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:mo>&#x22EF;</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> for some special cases [<xref ref-type="bibr" rid="B19-sensors-16-00722">19</xref>].</p>
      <p>It is also necessary to find an effective method to solve Equation (<xref ref-type="disp-formula" rid="FD22-sensors-16-00722">22</xref>). The Cholesky factorization is one of standard effective methods for solving linear systems compared to the Gaussian elimination or the LU decomposition. Note that any symmetric and positive definite matrix <inline-formula>
        <mml:math id="mm119" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">A</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula> can be expressed as <inline-formula>
        <mml:math id="mm120" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">A</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mi mathvariant="bold">L</mml:mi>
              <mml:mo mathvariant="bold">&#x3A3;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="bold">L</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> for some unit lower triangular matrix <inline-formula>
        <mml:math id="mm121" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">L</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula> and diagonal matrix <bold>&#x3A3;</bold> with positive entries on the diagonal. For each step, we decompose <inline-formula>
        <mml:math id="mm122" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">Hess</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mo  stretchy="false">(</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:mo  stretchy="false">)</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> as <inline-formula>
        <mml:math id="mm123" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">Hess</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mi>k</mml:mi>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">L</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:msub>
                <mml:mo mathvariant="bold">&#x3A3;</mml:mo>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:msubsup>
                <mml:mi mathvariant="bold">L</mml:mi>
                <mml:mi>k</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msubsup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, then solve the following three sub-equations.
      <disp-formula id="FD24-sensors-16-00722">
        <label>(24)</label>
        <mml:math id="mm124" display="block">
          <mml:semantics>
            <mml:mtable displaystyle="true">
              <mml:mtr>
                <mml:mtd/>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:msub>
                      <mml:mi mathvariant="bold">L</mml:mi>
                      <mml:mi>k</mml:mi>
                    </mml:msub>
                    <mml:msubsup>
                      <mml:mi>&#x3BE;</mml:mi>
                      <mml:mi>k</mml:mi>
                      <mml:msup>
                        <mml:mrow/>
                        <mml:mo>&#x2032;</mml:mo>
                      </mml:msup>
                    </mml:msubsup>
                    <mml:mo>=</mml:mo>
                    <mml:mo>-</mml:mo>
                    <mml:mo form="prefix">grad</mml:mo>
                    <mml:mi>f</mml:mi>
                    <mml:mrow>
                      <mml:mo  stretchy="false">(</mml:mo>
                      <mml:msub>
                        <mml:mi mathvariant="bold">P</mml:mi>
                        <mml:mi>k</mml:mi>
                      </mml:msub>
                      <mml:mo  stretchy="false">)</mml:mo>
                    </mml:mrow>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      <disp-formula id="FD25-sensors-16-00722">
        <label>(25)</label>
        <mml:math id="mm125" display="block">
          <mml:semantics>
            <mml:mtable displaystyle="true">
              <mml:mtr>
                <mml:mtd/>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:msub>
                      <mml:mo mathvariant="bold">&#x3A3;</mml:mo>
                      <mml:mi>k</mml:mi>
                    </mml:msub>
                    <mml:msubsup>
                      <mml:mi>&#x3BE;</mml:mi>
                      <mml:mi>k</mml:mi>
                      <mml:msup>
                        <mml:mrow/>
                        <mml:mrow>
                          <mml:mo>&#x2033;</mml:mo>
                        </mml:mrow>
                      </mml:msup>
                    </mml:msubsup>
                    <mml:mo>=</mml:mo>
                    <mml:msubsup>
                      <mml:mi>&#x3BE;</mml:mi>
                      <mml:mi>k</mml:mi>
                      <mml:msup>
                        <mml:mrow/>
                        <mml:mo>&#x2032;</mml:mo>
                      </mml:msup>
                    </mml:msubsup>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      <disp-formula id="FD26-sensors-16-00722">
        <label>(26)</label>
        <mml:math id="mm126" display="block">
          <mml:semantics>
            <mml:mtable displaystyle="true">
              <mml:mtr>
                <mml:mtd/>
                <mml:mtd columnalign="left">
                  <mml:mrow>
                    <mml:msub>
                      <mml:mi mathvariant="bold">L</mml:mi>
                      <mml:mi>k</mml:mi>
                    </mml:msub>
                    <mml:msub>
                      <mml:mi>&#x3BE;</mml:mi>
                      <mml:mi>k</mml:mi>
                    </mml:msub>
                    <mml:mo>=</mml:mo>
                    <mml:msubsup>
                      <mml:mi>&#x3BE;</mml:mi>
                      <mml:mi>k</mml:mi>
                      <mml:msup>
                        <mml:mrow/>
                        <mml:mrow>
                          <mml:mo>&#x2033;</mml:mo>
                        </mml:mrow>
                      </mml:msup>
                    </mml:msubsup>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      so that <inline-formula>
        <mml:math id="mm127" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mo mathvariant="bold">&#x3A3;</mml:mo>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:msubsup>
                <mml:mi mathvariant="bold">L</mml:mi>
                <mml:mi>k</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msubsup>
              <mml:msub>
                <mml:mi>&#x3BE;</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:msubsup>
                <mml:mi>&#x3BE;</mml:mi>
                <mml:mi>k</mml:mi>
                <mml:msup>
                  <mml:mrow/>
                  <mml:mo>&#x2032;</mml:mo>
                </mml:msup>
              </mml:msubsup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, and <inline-formula>
        <mml:math id="mm128" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msubsup>
                <mml:mi mathvariant="bold">L</mml:mi>
                <mml:mi>k</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msubsup>
              <mml:msub>
                <mml:mi>&#x3BE;</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:msubsup>
                <mml:mi>&#x3BE;</mml:mi>
                <mml:mi>k</mml:mi>
                <mml:msup>
                  <mml:mrow/>
                  <mml:mrow>
                    <mml:mo>&#x2033;</mml:mo>
                  </mml:mrow>
                </mml:msup>
              </mml:msubsup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. However, when <inline-formula>
        <mml:math id="mm129" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">Hess</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mo  stretchy="false">(</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:mo  stretchy="false">)</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> is not positive definite, a Cholesky decomposition cannot be performed since its eigenvalues are sometimes very small negative numbers caused by rounding in computing and noise in the data. To overcome this kind of problems, we define a positive integer number <italic>p</italic> to avoid the computation error by replacing <inline-formula>
        <mml:math id="mm130" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mo mathvariant="bold">&#x3A3;</mml:mo>
              <mml:mi>k</mml:mi>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> by <italic>p</italic> when <inline-formula>
        <mml:math id="mm131" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mo mathvariant="bold">&#x3A3;</mml:mo>
              <mml:mi>k</mml:mi>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> is non-positive definite, and continue the factorization. If the absolute value of <inline-formula>
        <mml:math id="mm132" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">grad</mml:mo>
              <mml:mi>f</mml:mi>
              <mml:mo  stretchy="false">(</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mi>k</mml:mi>
              </mml:msub>
              <mml:mo  stretchy="false">)</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> is small or <inline-formula>
        <mml:math id="mm133" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mrow>
                <mml:mi>k</mml:mi>
                <mml:mo>+</mml:mo>
                <mml:mn>1</mml:mn>
              </mml:mrow>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> is close to <inline-formula>
        <mml:math id="mm134" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mi>k</mml:mi>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula>, then we terminate <inline-formula>
        <mml:math id="mm135" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mrow>
                <mml:mi>k</mml:mi>
                <mml:mo>+</mml:mo>
                <mml:mn>1</mml:mn>
              </mml:mrow>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> as the minimum, otherwise we continue the iteration. We always wish to construct <inline-formula>
        <mml:math id="mm136" display="block">
          <mml:semantics>
            <mml:msub>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mi>k</mml:mi>
            </mml:msub>
          </mml:semantics>
        </mml:math>
      </inline-formula> with the convergence to the minimum at a rapid rate, so that few iterations are needed until the stopping criterion is satisfied. However, this has to be counterbalanced with the computation cost per iteration because of the trade-off between fast convergence and higher computational cost per iteration.</p>
      <p>In Equation (<xref ref-type="disp-formula" rid="FD17-sensors-16-00722">17</xref>), we can discard the constraint <inline-formula>
        <mml:math id="mm137" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">Pe</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn mathvariant="bold">0</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> during the computational process. The reason is explained as follows. Let us assume that <inline-formula>
        <mml:math id="mm138" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mo>&#x2208;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="double-struck">R</mml:mi>
                <mml:mrow>
                  <mml:mi>n</mml:mi>
                  <mml:mo>&#xD7;</mml:mo>
                  <mml:mi>r</mml:mi>
                </mml:mrow>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> is partitioned as
      <disp-formula>
        <mml:math id="mm139" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">P</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mfenced open="[" close="]">
                <mml:mtable>
                  <mml:mtr>
                    <mml:mtd>
                      <mml:msub>
                        <mml:mi mathvariant="bold">P</mml:mi>
                        <mml:mn>1</mml:mn>
                      </mml:msub>
                    </mml:mtd>
                  </mml:mtr>
                  <mml:mtr>
                    <mml:mtd>
                      <mml:msub>
                        <mml:mi mathvariant="bold">P</mml:mi>
                        <mml:mn>2</mml:mn>
                      </mml:msub>
                    </mml:mtd>
                  </mml:mtr>
                </mml:mtable>
              </mml:mfenced>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula>
      where <inline-formula>
        <mml:math id="mm140" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mn>1</mml:mn>
              </mml:msub>
              <mml:mo>&#x2208;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="double-struck">R</mml:mi>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:mi>n</mml:mi>
                  <mml:mo>-</mml:mo>
                  <mml:mi>m</mml:mi>
                  <mml:mo  stretchy="false">)</mml:mo>
                  <mml:mo>&#xD7;</mml:mo>
                  <mml:mi>r</mml:mi>
                </mml:mrow>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> and <inline-formula>
        <mml:math id="mm141" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mn>2</mml:mn>
              </mml:msub>
              <mml:mo>&#x2208;</mml:mo>
              <mml:msup>
                <mml:mi mathvariant="double-struck">R</mml:mi>
                <mml:mrow>
                  <mml:mi>m</mml:mi>
                  <mml:mo>&#xD7;</mml:mo>
                  <mml:mi>r</mml:mi>
                </mml:mrow>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. Since <inline-formula>
        <mml:math id="mm142" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">H</mml:mi>
              <mml:mo>&#x2218;</mml:mo>
              <mml:msup>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
                <mml:mi>T</mml:mi>
              </mml:msup>
              <mml:mo>=</mml:mo>
              <mml:mi mathvariant="bold">H</mml:mi>
              <mml:mo>&#x2218;</mml:mo>
              <mml:mi mathvariant="bold">D</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, we have <inline-formula>
        <mml:math id="mm143" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>&#x3BA;</mml:mi>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msub>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mn>2</mml:mn>
                </mml:msub>
                <mml:msubsup>
                  <mml:mi mathvariant="bold">P</mml:mi>
                  <mml:mn>2</mml:mn>
                  <mml:mi>T</mml:mi>
                </mml:msubsup>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:mi>&#x3BA;</mml:mi>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi mathvariant="bold">A</mml:mi>
                <mml:msup>
                  <mml:mi mathvariant="bold">A</mml:mi>
                  <mml:mi>T</mml:mi>
                </mml:msup>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. If <inline-formula>
        <mml:math id="mm144" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msup>
                <mml:mi mathvariant="bold">A</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msup>
              <mml:mi mathvariant="bold">e</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mn>2</mml:mn>
              </mml:msub>
              <mml:mi mathvariant="bold">e</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn mathvariant="bold">0</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, it imples that <inline-formula>
        <mml:math id="mm145" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mn>2</mml:mn>
              </mml:msub>
              <mml:msubsup>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mn>2</mml:mn>
                <mml:mi>T</mml:mi>
              </mml:msubsup>
              <mml:mo>=</mml:mo>
              <mml:mi mathvariant="bold">A</mml:mi>
              <mml:msup>
                <mml:mi mathvariant="bold">A</mml:mi>
                <mml:mi>T</mml:mi>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>, <italic>i.e.</italic>, there exists an orthogonal transformation <inline-formula>
        <mml:math id="mm146" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">Q</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula> satisfying <inline-formula>
        <mml:math id="mm147" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi mathvariant="bold">P</mml:mi>
                <mml:mn>2</mml:mn>
              </mml:msub>
              <mml:mi mathvariant="bold">Q</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mi mathvariant="bold">A</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. It was well-known as the ProCrustes problem [<xref ref-type="bibr" rid="B4-sensors-16-00722">4</xref>]. Hence, the problem Equation (<xref ref-type="disp-formula" rid="FD17-sensors-16-00722">17</xref>) becomes an unconstrained optimization and it can be solve efficiently by the modified Newton&#x2019;s method. However, the equality constraint <inline-formula>
        <mml:math id="mm148" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="bold">Pe</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn mathvariant="bold">0</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> reduces the flexibility of <inline-formula>
        <mml:math id="mm149" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">P</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula> and can help the convergence to the global minimum in some cases.</p>
      <p>In summary, we use the following procedures to solve the localization problem Equation (<xref ref-type="disp-formula" rid="FD17-sensors-16-00722">17</xref>) as illustrated in <xref ref-type="fig" rid="sensors-16-00722-f001">Figure 1</xref>. </p>
      <statement>
        <label><bold>Remark 1.</bold>&#xA0;</label>
        <p><italic>The modification of the Newton&#x2019;s method is illustrated by the solution path on the function in [<xref ref-type="bibr" rid="B19-sensors-16-00722">19</xref>], which is able to follow the shape of the U-valley and converges to the minimum using only finite difference gradients. For the deployment of other adaptive methods for the mesh refinement or the discrete Newton-like method, we will consider these methods as well as their convergence issues in the future work.</italic></p>
      </statement>
      <statement>
        <label><bold>Remark 2.</bold>&#xA0;</label>
        <p><italic>It has been shown that the conventional MDS has the time complexity of <inline-formula>
          <mml:math id="mm150" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="script">O</mml:mi>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msup>
                  <mml:mi>n</mml:mi>
                  <mml:mn>3</mml:mn>
                </mml:msup>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>, while the WMDS [<xref ref-type="bibr" rid="B7-sensors-16-00722">7</xref>] performed well for sparse networks but it is about two orders of magnitude slower than the MDS for larger networks (more than 100 node-networks). This is because the refinement strategy in [<xref ref-type="bibr" rid="B7-sensors-16-00722">7</xref>] leads to a tradeoff between solution quality and computation cost. For the dwMDS algorithm [<xref ref-type="bibr" rid="B8-sensors-16-00722">8</xref>], the authors proved that it takes <inline-formula>
          <mml:math id="mm151" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="script">O</mml:mi>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi>n</mml:mi>
                <mml:mi>L</mml:mi>
                <mml:mo>+</mml:mo>
                <mml:msup>
                  <mml:mi>n</mml:mi>
                  <mml:mn>2</mml:mn>
                </mml:msup>
                <mml:mi>L</mml:mi>
                <mml:msub>
                  <mml:mi>d</mml:mi>
                  <mml:mrow>
                    <mml:mi>t</mml:mi>
                    <mml:mi>h</mml:mi>
                    <mml:mi>r</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:msub>
                  <mml:mi>e</mml:mi>
                  <mml:mrow>
                    <mml:mi>d</mml:mi>
                    <mml:mi>w</mml:mi>
                    <mml:mi>M</mml:mi>
                    <mml:mi>D</mml:mi>
                    <mml:mi>S</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> time, where L is the number of iterations required until the stopping rule is satisfied, <inline-formula>
          <mml:math id="mm152" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:msub>
                  <mml:mi>d</mml:mi>
                  <mml:mrow>
                    <mml:mi>t</mml:mi>
                    <mml:mi>h</mml:mi>
                    <mml:mi>r</mml:mi>
                  </mml:mrow>
                </mml:msub>
                <mml:mo>=</mml:mo>
                <mml:mi mathvariant="script">O</mml:mi>
                <mml:mrow>
                  <mml:mo  stretchy="false">(</mml:mo>
                  <mml:msup>
                    <mml:mi>n</mml:mi>
                    <mml:mrow>
                      <mml:mn>1</mml:mn>
                      <mml:mo>/</mml:mo>
                      <mml:mi>r</mml:mi>
                    </mml:mrow>
                  </mml:msup>
                  <mml:mo  stretchy="false">)</mml:mo>
                </mml:mrow>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula> is the threshold distance, and <inline-formula>
          <mml:math id="mm153" display="block">
            <mml:semantics>
              <mml:msub>
                <mml:mi>e</mml:mi>
                <mml:mrow>
                  <mml:mi>d</mml:mi>
                  <mml:mi>w</mml:mi>
                  <mml:mi>M</mml:mi>
                  <mml:mi>D</mml:mi>
                  <mml:mi>S</mml:mi>
                </mml:mrow>
              </mml:msub>
            </mml:semantics>
          </mml:math>
        </inline-formula> depends on <inline-formula>
          <mml:math id="mm154" display="block">
            <mml:semantics>
              <mml:msub>
                <mml:mi>d</mml:mi>
                <mml:mrow>
                  <mml:mi>t</mml:mi>
                  <mml:mi>h</mml:mi>
                  <mml:mi>r</mml:mi>
                </mml:mrow>
              </mml:msub>
            </mml:semantics>
          </mml:math>
        </inline-formula> in a nonlinear way. A drawback of the dwMDS is that complexity, convergence time and initial estimate requirements for each transmission time depend sensitively on heavy weights and range measurement accuracy. For our approach, it can be verified that the computing for matrix decomposition takes <inline-formula>
          <mml:math id="mm155" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="script">O</mml:mi>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:msup>
                  <mml:mi>n</mml:mi>
                  <mml:mi>&#x3BA;</mml:mi>
                </mml:msup>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>, where <inline-formula>
          <mml:math id="mm156" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mn>1</mml:mn>
                <mml:mo>&#x2264;</mml:mo>
                <mml:mi>&#x3BA;</mml:mi>
                <mml:mo>&lt;</mml:mo>
                <mml:mn>3</mml:mn>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>, thus the total cost can be computed as <inline-formula>
          <mml:math id="mm157" display="block">
            <mml:semantics>
              <mml:mrow>
                <mml:mi mathvariant="script">O</mml:mi>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mi>K</mml:mi>
                <mml:msup>
                  <mml:mi>n</mml:mi>
                  <mml:mi>&#x3BA;</mml:mi>
                </mml:msup>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:semantics>
          </mml:math>
        </inline-formula>, where K is the number of iterations. Thus, our approach compares favorably to the conventional methods in terms of the complexity.</italic></p>
      </statement>
    </sec>
    <sec id="sec4-sensors-16-00722">
      <title>4. Numerical Evaluation</title>
      <p>In this section, the effectiveness of the proposed localization approach based on the modified Newton&#x2019;s method is numerically investigated. Moreover, its location estimator is employed and compared. We consider a WSN consisting of 20 nodes placed in an area <inline-formula>
        <mml:math id="mm158" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo>[</mml:mo>
              <mml:mo>-</mml:mo>
              <mml:mn>20</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:mn>20</mml:mn>
              <mml:mo>]</mml:mo>
              <mml:mo>&#xD7;</mml:mo>
              <mml:mo>[</mml:mo>
              <mml:mo>-</mml:mo>
              <mml:mn>20</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:mn>20</mml:mn>
              <mml:mo>]</mml:mo>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> m<inline-formula>
        <mml:math id="mm159" display="block">
          <mml:semantics>
            <mml:msup>
              <mml:mrow/>
              <mml:mn>2</mml:mn>
            </mml:msup>
          </mml:semantics>
        </mml:math>
      </inline-formula> with 8 of them are anchors and its geometry is illustrated in <xref ref-type="fig" rid="sensors-16-00722-f002">Figure 2</xref>, <italic>i.e.</italic>, <inline-formula>
        <mml:math id="mm160" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>n</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn>20</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:mspace width="3.33333pt"/>
              <mml:mi>m</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn>8</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> and <inline-formula>
        <mml:math id="mm161" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>n</mml:mi>
              <mml:mo>-</mml:mo>
              <mml:mi>m</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn>12</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. The anchor locations are (20,20), (&#x2212;20, &#x2212;20), (20, 0), (&#x2212;20, 0), (20, &#x2212;20), (20, &#x2212;20), (0, 20), (0, &#x2212;20). The unknown sensor locations are randomly placed in this area. The maximum communication range between the nodes is set to be 25 meters. For the parameters in the path loss model of Equation (<xref ref-type="disp-formula" rid="FD10-sensors-16-00722">10</xref>), <inline-formula>
        <mml:math id="mm162" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi>L</mml:mi>
                <mml:mn>0</mml:mn>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:mo>-</mml:mo>
              <mml:mn>36</mml:mn>
              <mml:mo>.</mml:mo>
              <mml:mn>029</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> dB, <inline-formula>
        <mml:math id="mm163" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>&#x3B3;</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn>2</mml:mn>
              <mml:mo>.</mml:mo>
              <mml:mn>386</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:msub>
                <mml:mi>d</mml:mi>
                <mml:mn>0</mml:mn>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:mn>1</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> meter and <inline-formula>
        <mml:math id="mm164" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:msub>
                <mml:mi>&#x3C3;</mml:mi>
                <mml:mrow>
                  <mml:mi>i</mml:mi>
                  <mml:mi>j</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:mi>&#x3C3;</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> for <inline-formula>
        <mml:math id="mm165" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>i</mml:mi>
              <mml:mo>,</mml:mo>
              <mml:mi>j</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn>1</mml:mn>
              <mml:mo>,</mml:mo>
              <mml:mo>&#x22EF;</mml:mo>
              <mml:mo>,</mml:mo>
              <mml:mi>n</mml:mi>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>. We define the root mean square error (RMSE) by
      <disp-formula id="FD27-sensors-16-00722">
        <label>(27)</label>
        <mml:math id="mm166" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mo form="prefix">RMSE</mml:mo>
              <mml:mo>=</mml:mo>
              <mml:msup>
                <mml:mfenced separators="" open="(" close=")">
                  <mml:mfrac>
                    <mml:mn>1</mml:mn>
                    <mml:mrow>
                      <mml:mi>n</mml:mi>
                      <mml:mo>-</mml:mo>
                      <mml:mi>m</mml:mi>
                    </mml:mrow>
                  </mml:mfrac>
                  <mml:munderover>
                    <mml:mo>&#x2211;</mml:mo>
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mo>=</mml:mo>
                      <mml:mn>1</mml:mn>
                    </mml:mrow>
                    <mml:mrow>
                      <mml:mi>n</mml:mi>
                      <mml:mo>-</mml:mo>
                      <mml:mi>m</mml:mi>
                    </mml:mrow>
                  </mml:munderover>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mo>|</mml:mo>
                  </mml:mrow>
                  <mml:msubsup>
                    <mml:mi mathvariant="bold">p</mml:mi>
                    <mml:mi>i</mml:mi>
                    <mml:mtext>actual</mml:mtext>
                  </mml:msubsup>
                  <mml:mo>-</mml:mo>
                  <mml:msubsup>
                    <mml:mi mathvariant="bold">p</mml:mi>
                    <mml:mi>i</mml:mi>
                    <mml:mtext>estimated</mml:mtext>
                  </mml:msubsup>
                  <mml:msubsup>
                    <mml:mrow>
                      <mml:mo>|</mml:mo>
                      <mml:mo>|</mml:mo>
                    </mml:mrow>
                    <mml:mn>2</mml:mn>
                    <mml:mn>2</mml:mn>
                  </mml:msubsup>
                </mml:mfenced>
                <mml:mfrac>
                  <mml:mn>1</mml:mn>
                  <mml:mn>2</mml:mn>
                </mml:mfrac>
              </mml:msup>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </disp-formula></p>
      <p>In the first experiment, we investigate the performance of the proposed algorithm as shown in <xref ref-type="fig" rid="sensors-16-00722-f003">Figure 3</xref>. It shows the effectiveness of the location estimation of our proposed scheme for a single trial with <inline-formula>
        <mml:math id="mm167" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi>&#x3C3;</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn>3</mml:mn>
              <mml:mo>.</mml:mo>
              <mml:mn>98</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> dB [<xref ref-type="bibr" rid="B13-sensors-16-00722">13</xref>] in two cases: (a) presence of anchor locations and (b) absence of anchor locations. By &#x201C;presence of anchor locations&#x201D;, we mean that these locations are used in the initial guess for <inline-formula>
        <mml:math id="mm168" display="block">
          <mml:semantics>
            <mml:mi mathvariant="bold">P</mml:mi>
          </mml:semantics>
        </mml:math>
      </inline-formula>, and inverse for &#x201C;absence of anchor locations&#x201D; case. A maximum RMSEs of <inline-formula>
        <mml:math id="mm169" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mn>1</mml:mn>
              <mml:mo>.</mml:mo>
              <mml:mn>4854</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> meter and <inline-formula>
        <mml:math id="mm170" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mn>1</mml:mn>
              <mml:mo>.</mml:mo>
              <mml:mn>8833</mml:mn>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula> meter are observed over 100 simulations in <xref ref-type="fig" rid="sensors-16-00722-f003">Figure 3</xref>a,b, respectively. It indicates that better initial points leads to better final results for our proposed scheme.</p>
      <p>For the purpose of comparison, the RMSEs of our scheme and several schemes <italic>versus</italic> <italic>&#x3C3;</italic> are shown in <xref ref-type="fig" rid="sensors-16-00722-f004">Figure 4</xref>. Each result is collected after 1000 independent runs. After obtaining the distance information in Equation (<xref ref-type="disp-formula" rid="FD12-sensors-16-00722">12</xref>), we get the standard SDP estimator (SDP is used in the context of linear matrix inequalities and can be efficiently solved by interior point methods, which has the complexity of <inline-formula>
        <mml:math id="mm172" display="block">
          <mml:semantics>
            <mml:mrow>
              <mml:mi mathvariant="script">O</mml:mi>
              <mml:mo  stretchy="false">(</mml:mo>
              <mml:msup>
                <mml:mi>N</mml:mi>
                <mml:mrow>
                  <mml:mn>4</mml:mn>
                  <mml:mo>.</mml:mo>
                  <mml:mn>5</mml:mn>
                </mml:mrow>
              </mml:msup>
              <mml:mo form="prefix">ln</mml:mo>
              <mml:mrow>
                <mml:mo  stretchy="false">(</mml:mo>
                <mml:mn>1</mml:mn>
                <mml:mo>/</mml:mo>
                <mml:mi>&#x3F5;</mml:mi>
                <mml:mo  stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:semantics>
        </mml:math>
      </inline-formula>), here, <italic>&#x3F5;</italic> is a given solution precision) by using the CVX package [<xref ref-type="bibr" rid="B18-sensors-16-00722">18</xref>,<xref ref-type="bibr" rid="B19-sensors-16-00722">19</xref>]. From the figure, we observe that our solution achieve the solution that better than the conventional MDS, WMDS, and dwMDS methods when the noise is large, and quite comparable estimation accuracy with the standard SDP for a small value of <italic>&#x3C3;</italic>, since our solution depends on how good initial points are. It can be improved if we can choose a good parameter to set up. <xref ref-type="fig" rid="sensors-16-00722-f004">Figure 4</xref>b give us such an example. However, note that in this particular simulation with MATLAB implementation, the proposed method is faster than the others in running time.</p>
      <p>The results indicate that our scheme is more suitable for the case of limited anchor node information. This is a good property for some scenarios where anchor node positions are not available. Thus, the obtained solution can be provided as a good initial point for other fine localization algorithms.</p>
    </sec>
    <sec sec-type="conclusions" id="sec5-sensors-16-00722">
      <title>5. Conclusions</title>
      <p>In contrast to many existing algorithms developed for the Euclidean distance matrix completion problem or its relaxation, we cast the problem under unconstrained formulation in terms of the location vectors directly and propose a new scheme using a modified Newton&#x2019;s method instead. We manage the complexity by organizing the gradient and Hessian matrices. The theory is simple, but the results are effective and robust for localization in WSNs for intelligent IoT.</p>
    </sec>
  </body>
  <back>
    <ack>
      <title>Acknowledgments</title>
      <p>This work was partly supported by the Human Resources Development program of the KETEP grant funded by the Korea government MOTIE (No. 20154010200570), and by the NRF grant funded by the Korean government MSIP (No. 2014R1A5A1011478).</p>
    </ack>
    <notes>
      <title>Author Contributions</title>
      <p>The work was realized with the collaboration of all of the authors. Thu L. N. Nguyen contributed the main results and code implementation. Yoan Shin organized the work, provided the funding, supervised the research and reviewed the draft of the paper. All authors discussed the results, approved the final version, and wrote the paper.</p>
    </notes>
    <notes>
      <title>Conflicts of Interest</title>
      <p>The authors declare no conflict of interest.</p>
    </notes>
    <ref-list>
      <title>References</title>
      <ref id="B1-sensors-16-00722">
        <label>1.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Patwari</surname>
              <given-names>N.</given-names>
            </name>
            <name>
              <surname>Ash</surname>
              <given-names>J.N.</given-names>
            </name>
            <name>
              <surname>Kyperountas</surname>
              <given-names>S.</given-names>
            </name>
            <name>
              <surname>Hero</surname>
              <given-names>A.O.</given-names>
            </name>
            <name>
              <surname>Moses</surname>
              <given-names>R.L.</given-names>
            </name>
            <name>
              <surname>Correal</surname>
              <given-names>N.S.</given-names>
            </name>
          </person-group>
          <article-title>Locating the nodes: Cooperative localization in wireless sensor networks</article-title>
          <source>IEEE Signal Process. Mag.</source>
          <year>2005</year>
          <volume>22</volume>
          <fpage>54</fpage>
          <lpage>69</lpage>
          <pub-id pub-id-type="doi">10.1109/MSP.2005.1458287</pub-id>
        </citation>
      </ref>
      <ref id="B2-sensors-16-00722">
        <label>2.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Bulusu</surname>
              <given-names>N.</given-names>
            </name>
            <name>
              <surname>Heidemann</surname>
              <given-names>J.</given-names>
            </name>
            <name>
              <surname>Estrin</surname>
              <given-names>D.</given-names>
            </name>
          </person-group>
          <article-title>GPS-less low cost outdoor localization for very small devices</article-title>
          <source>IEEE Pers. Commun.</source>
          <year>2000</year>
          <volume>7</volume>
          <fpage>28</fpage>
          <lpage>34</lpage>
          <pub-id pub-id-type="doi">10.1109/98.878533</pub-id>
        </citation>
      </ref>
      <ref id="B3-sensors-16-00722">
        <label>3.</label>
        <citation citation-type="confproc">
          <person-group person-group-type="author">
            <name>
              <surname>Gwon</surname>
              <given-names>Y.</given-names>
            </name>
            <name>
              <surname>Jain</surname>
              <given-names>R.</given-names>
            </name>
            <name>
              <surname>Kawahara</surname>
              <given-names>T.</given-names>
            </name>
          </person-group>
          <article-title>Robust indoor location estimation of stationary and mobile users</article-title>
          <source>Proceedings of the Twenty-third Annual Joint Conference of the IEEE Computer and Communications Societies (INFOCOM 2004)</source>
          <conf-loc>Hong Kong, China</conf-loc>
          <conf-date>7&#x2013;11 March 2004</conf-date>
          <fpage>1032</fpage>
          <lpage>1043</lpage>
        </citation>
      </ref>
      <ref id="B4-sensors-16-00722">
        <label>4.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Biwas</surname>
              <given-names>P.</given-names>
            </name>
            <name>
              <surname>Lian</surname>
              <given-names>T.C.</given-names>
            </name>
            <name>
              <surname>Wang</surname>
              <given-names>T.C.</given-names>
            </name>
            <name>
              <surname>Ye</surname>
              <given-names>Y.</given-names>
            </name>
          </person-group>
          <article-title>Semidefinite programming approaches for sensor network localization with noisy distance measurements</article-title>
          <source>IEEE Trans. Autom. Sci. Eng.</source>
          <year>2006</year>
          <volume>3</volume>
          <fpage>360</fpage>
          <lpage>371</lpage>
          <pub-id pub-id-type="doi">10.1109/TASE.2006.877401</pub-id>
        </citation>
      </ref>
      <ref id="B5-sensors-16-00722">
        <label>5.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Ouyang</surname>
              <given-names>R.W.</given-names>
            </name>
            <name>
              <surname>Wong</surname>
              <given-names>A.K.S.</given-names>
            </name>
            <name>
              <surname>Lea</surname>
              <given-names>C.T.</given-names>
            </name>
          </person-group>
          <article-title>Received signal strength based wireless localization via semidefinite programming: Noncooperative and cooperative schemes</article-title>
          <source>IEEE Trans. Veh. Technol.</source>
          <year>2010</year>
          <volume>59</volume>
          <fpage>1307</fpage>
          <lpage>1318</lpage>
          <pub-id pub-id-type="doi">10.1109/TVT.2010.2040096</pub-id>
        </citation>
      </ref>
      <ref id="B6-sensors-16-00722">
        <label>6.</label>
        <citation citation-type="confproc">
          <person-group person-group-type="author">
            <name>
              <surname>Biswas</surname>
              <given-names>P.</given-names>
            </name>
            <name>
              <surname>Ye</surname>
              <given-names>Y.</given-names>
            </name>
          </person-group>
          <article-title>Semidefinite programming for ad hoc wireless sensor network localization</article-title>
          <source>Proceedings of the Third International Symposium on Information Processing in Sensor Networks</source>
          <conf-loc>Berkeley, CA, USA</conf-loc>
          <conf-date>26&#x2013;27 April 2004</conf-date>
          <fpage>46</fpage>
          <lpage>54</lpage>
        </citation>
      </ref>
      <ref id="B7-sensors-16-00722">
        <label>7.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Chan</surname>
              <given-names>F.</given-names>
            </name>
            <name>
              <surname>So</surname>
              <given-names>H.C.</given-names>
            </name>
          </person-group>
          <article-title>Efficient weighted multidimensional scaling for wireless sensor network localization</article-title>
          <source>IEEE Trans. Signal Process.</source>
          <year>2009</year>
          <volume>57</volume>
          <fpage>4548</fpage>
          <lpage>4553</lpage>
          <pub-id pub-id-type="doi">10.1109/TSP.2009.2024869</pub-id>
        </citation>
      </ref>
      <ref id="B8-sensors-16-00722">
        <label>8.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Costa</surname>
              <given-names>J.A.</given-names>
            </name>
            <name>
              <surname>Patwari</surname>
              <given-names>N.</given-names>
            </name>
            <name>
              <surname>Hero</surname>
              <given-names>A.O.</given-names>
			  <suffix>III</suffix>
            </name>
          </person-group>
          <article-title>Distributed weighted-multidimensional scaling for node localization in sensor networks</article-title>
          <source>ACM Trans. Sens. Netw.</source>
          <year>2006</year>
          <volume>2</volume>
          <fpage>39</fpage>
          <lpage>64</lpage>
          <pub-id pub-id-type="doi">10.1145/1138127.1138129</pub-id>
        </citation>
      </ref>
      <ref id="B9-sensors-16-00722">
        <label>9.</label>
        <citation citation-type="confproc">
          <person-group person-group-type="author">
            <name>
              <surname>Shang</surname>
              <given-names>Y.</given-names>
            </name>
            <name>
              <surname>Ruml</surname>
              <given-names>W.</given-names>
            </name>
          </person-group>
          <article-title>Improved MDS-based localization</article-title>
          <source>Proceedings of the Twenty-third AnnualJoint Conference of the IEEE Computer and Communications Societies</source>
          <conf-loc>Hong Kong, China</conf-loc>
          <conf-date>7&#x2013;11 March 2004</conf-date>
          <fpage>2640</fpage>
          <lpage>2651</lpage>
        </citation>
      </ref>
      <ref id="B10-sensors-16-00722">
        <label>10.</label>
        <citation citation-type="web">
          <person-group person-group-type="author">
            <name>
              <surname>Cassioli</surname>
              <given-names>A.</given-names>
            </name>
          </person-group>
          <article-title>Global Optimization of Highly Multimodal Problems</article-title>
          <comment>Available online: <ext-link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://www-dsi.ing.unifi.it/DRIIA/RaccoltaTesi/Cassioli.pdf" ext-link-type="uri">http://www-dsi.ing.unifi.it/DRIIA/RaccoltaTesi/Cassioli.pdf</ext-link></comment>
          <access-date>(accessed on 19 August 2014)</access-date>
        </citation>
      </ref>
      <ref id="B11-sensors-16-00722">
        <label>11.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Alfakih</surname>
              <given-names>A.</given-names>
            </name>
            <name>
              <surname>Khandani</surname>
              <given-names>A.</given-names>
            </name>
            <name>
              <surname>Wolkowicz</surname>
              <given-names>H.</given-names>
            </name>
          </person-group>
          <article-title>Solving Euclidean distance matrix completion problems via semidefinite programming</article-title>
          <source>Comput. Optim. Appl.</source>
          <year>1999</year>
          <volume>12</volume>
          <fpage>13</fpage>
          <lpage>30</lpage>
          <pub-id pub-id-type="doi">10.1023/A:1008655427845</pub-id>
        </citation>
      </ref>
      <ref id="B12-sensors-16-00722">
        <label>12.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Journ&#xE9;e</surname>
              <given-names>M.</given-names>
            </name>
            <name>
              <surname>Bach</surname>
              <given-names>F.</given-names>
            </name>
            <name>
              <surname>Absil</surname>
              <given-names>P.-A.</given-names>
            </name>
            <name>
              <surname>Sepulchre</surname>
              <given-names>R.</given-names>
            </name>
          </person-group>
          <article-title>Low-rank optimization on the cone of positive semidefinite matrices</article-title>
          <source>SIAM J. Optim.</source>
          <year>2010</year>
          <volume>20</volume>
          <fpage>2327</fpage>
          <lpage>2351</lpage>
          <pub-id pub-id-type="doi">10.1137/080731359</pub-id>
        </citation>
      </ref>
      <ref id="B13-sensors-16-00722">
        <label>13.</label>
        <citation citation-type="book">
          <person-group person-group-type="author">
            <name>
              <surname>Rappaport</surname>
              <given-names>T.S.</given-names>
            </name>
          </person-group>
          <source>Wireless Communications: Principles and Practice</source>
          <publisher-name>Prentice-Hall</publisher-name>
          <publisher-loc>Upper Saddle River, NJ, USA</publisher-loc>
          <year>1996</year>
          <fpage>72</fpage>
          <lpage>73</lpage>
        </citation>
      </ref>
      <ref id="B14-sensors-16-00722">
        <label>14.</label>
        <citation citation-type="book">
          <person-group person-group-type="author">
            <name>
              <surname>Boyd</surname>
              <given-names>S.</given-names>
            </name>
            <name>
              <surname>Vandenberghe</surname>
              <given-names>L.</given-names>
            </name>
          </person-group>
          <source>Convex Optimization</source>
          <publisher-name>Cambridge University Press</publisher-name>
          <publisher-loc>Cambridge, UK</publisher-loc>
          <year>2004</year>
        </citation>
      </ref>
      <ref id="B15-sensors-16-00722">
        <label>15.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Kearsley</surname>
              <given-names>A.</given-names>
            </name>
            <name>
              <surname>Tapia</surname>
              <given-names>R.</given-names>
            </name>
            <name>
              <surname>Trosset</surname>
              <given-names>M.</given-names>
            </name>
          </person-group>
          <article-title>The solution of the metric stress and stress problems in multidimensional scaling by Newton&#x2019;s method</article-title>
          <source>Comput. Stat.</source>
          <year>1998</year>
          <volume>13</volume>
          <fpage>369</fpage>
          <lpage>396</lpage>
        </citation>
      </ref>
      <ref id="B16-sensors-16-00722">
        <label>16.</label>
        <citation citation-type="journal">
          <person-group person-group-type="author">
            <name>
              <surname>Ferreira</surname>
              <given-names>R.</given-names>
            </name>
            <name>
              <surname>Xavier</surname>
              <given-names>J.</given-names>
            </name>
            <name>
              <surname>Costeira</surname>
              <given-names>J.P.</given-names>
            </name>
            <name>
              <surname>Barroso</surname>
              <given-names>V.</given-names>
            </name>
          </person-group>
          <article-title>Newton algorithms for Riemannian distance related problems on connected locally symmetric manifolds</article-title>
          <source>IEEE J. Sel. Top. Signal Process.</source>
          <year>2013</year>
          <volume>7</volume>
          <fpage>634</fpage>
          <lpage>645</lpage>
          <pub-id pub-id-type="doi">10.1109/JSTSP.2013.2261799</pub-id>
        </citation>
      </ref>
      <ref id="B17-sensors-16-00722">
        <label>17.</label>
        <citation citation-type="confproc">
          <person-group person-group-type="author">
            <name>
              <surname>Ferreira</surname>
              <given-names>R.</given-names>
            </name>
            <name>
              <surname>Xavier</surname>
              <given-names>J.</given-names>
            </name>
            <name>
              <surname>Costeira</surname>
              <given-names>J.</given-names>
            </name>
            <name>
              <surname>Barroso</surname>
              <given-names>V.</given-names>
            </name>
          </person-group>
          <article-title>Newton method for Riemannian centroid computation in naturally reductive homogeneous spaces</article-title>
          <source>Proceedings of the2006 IEEE International Conference on Acoustics Speech and Signal Processing Proceedings</source>
          <conf-loc>Toulouse, France</conf-loc>
          <conf-date>14&#x2013;19 May 2006</conf-date>
          <fpage>704</fpage>
          <lpage>707</lpage>
        </citation>
      </ref>
      <ref id="B18-sensors-16-00722">
        <label>18.</label>
        <citation citation-type="book">
          <person-group person-group-type="author">
            <name>
              <surname>Xue</surname>
              <given-names>D.</given-names>
            </name>
            <name>
              <surname>Chen</surname>
              <given-names>Y.</given-names>
            </name>
          </person-group>
          <source>Solving Applied Mathematical Problems with MATLAB</source>
          <publisher-name>CRC Press</publisher-name>
          <publisher-loc>Boca Raton, FL, USA</publisher-loc>
          <year>2008</year>
        </citation>
      </ref>
      <ref id="B19-sensors-16-00722">
        <label>19.</label>
        <citation citation-type="web">
          <person-group person-group-type="author">
            <name>
              <surname>Grant</surname>
              <given-names>M.</given-names>
            </name>
            <name>
              <surname>Boyd</surname>
              <given-names>S.</given-names>
            </name>
          </person-group>
          <article-title>CVX: Matlab Software for Disciplined Convex Programming</article-title>
          <comment>Available online: <ext-link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://cvxr.com/cvx/" ext-link-type="uri">http://cvxr.com/cvx/</ext-link></comment>
          <access-date>(accessed on 19 August 2014)</access-date>
        </citation>
      </ref>
    </ref-list>
    <sec sec-type="display-objects">
      <title>Figures</title>
      <fig id="sensors-16-00722-f001" position="float">
        <label>Figure 1</label>
        <caption>
          <p>Procedures to solve the localization problem Equation (17).</p>
        </caption>
        <graphic xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="sensors-16-00722-g001.tif"/>
      </fig>
      <fig id="sensors-16-00722-f002" position="float">
        <label>Figure 2</label>
        <caption>
          <p>Geometry of a wireless sensor network for numerical evaluation.</p>
        </caption>
        <graphic xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="sensors-16-00722-g002.tif"/>
      </fig>
      <fig id="sensors-16-00722-f003" position="float">
        <label>Figure 3</label>
        <caption>
          <p>Single trial localization performance of the proposed scheme with <inline-formula>
            <mml:math id="mm171" display="block">
              <mml:semantics>
                <mml:mrow>
                  <mml:mi>&#x3C3;</mml:mi>
                  <mml:mo>=</mml:mo>
                  <mml:mn>3</mml:mn>
                  <mml:mo>.</mml:mo>
                  <mml:mn>98</mml:mn>
                </mml:mrow>
              </mml:semantics>
            </mml:math>
          </inline-formula> dB. (<bold>a</bold>) Presence of anchor locations (See text for details); (<bold>b</bold>) Absence of anchor locations (See text for details).</p>
        </caption>
        <graphic xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="sensors-16-00722-g003a.tif"/>
        <graphic xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="sensors-16-00722-g003b.tif"/>
      </fig>
      <fig id="sensors-16-00722-f004" position="float">
        <label>Figure 4</label>
        <caption>
          <p>Comparison of root mean square error (RMSE) performance of our scheme and several methods <italic>versus</italic> <italic>&#x3C3;</italic>. (<bold>a</bold>) A good precision for <inline-formula>
            <mml:math id="mm173" display="block">
              <mml:semantics>
                <mml:mi mathvariant="bold">P</mml:mi>
              </mml:semantics>
            </mml:math>
          </inline-formula>; (<bold>b</bold>) A bad precision for <inline-formula>
            <mml:math id="mm174" display="block">
              <mml:semantics>
                <mml:mi mathvariant="bold">P</mml:mi>
              </mml:semantics>
            </mml:math>
          </inline-formula>.</p>
        </caption>
        <graphic xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="sensors-16-00722-g004a.tif"/>
        <graphic xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="sensors-16-00722-g004b.tif"/>
      </fig>
    </sec>
  </back>
</article>
