Returns the real part (PR) array. PR has length number-of-nonzero-values.

@return real part
764028
public Double[] exportReal()
    {
        Double[] ad = new Double[indexSet.size()];
        int i = 0;
        for (IndexMN index: indexSet) {
            if (real.containsKey(index)) {
                ad[i] = real.get(index);
            } else {
                ad[i] = 0.0;
            }
            i++;
        }
        return ad;
    }
482855
public double[] getTrimmedInternalArray() {
        if (internalArray.length == lastIndex + 1) {
            return internalArray;
        }
        double[] newArray = new double[lastIndex + 1];
        System.arraycopy(internalArray, 0, newArray, 0, newArray.length);
        return newArray;
    }
1059043
public String[] getString() {
        String[] valueDestination = new String[ string.size() ];
        this.string.getValue(valueDestination);
        return valueDestination;
    }
1311661
public function getValues()
        {
            $values = [];

            foreach ($this->parts as $part) {
                if ($part instanceof Criterion) {
                    if ($part->getValue() !== null) {
                        $values[] = $part->getValue();
                    }
                } else {
                    foreach ($part->getValues() as $value) {
                        if ($value !== null) {
                            $values[] = $value;
                        }
                    }
                }
            }

            return $values;
        }
531389
public function getReal()
   {
      if(!$this->isExists())
      {
         throw new IOException("File not exist");
      }

      $temp = realpath($this->toString());

      if($this->isDir())
      {
         $temp = rtrim($temp, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
      }

      return new static($temp, $this->getRootDirectory());
   }
1038741
public function getRawMimeDirValue()
    {
        if (is_array($this->value)) {
            $value = $this->value[0];
        } else {
            $value = $this->value;
        }

        return strtr($value, [',' => '\,']);
    }
422048
public long[] extractULongArray() {
        final int[] array = element.value.ulong_att_value();
        long mask = 0x7fffffff;
        mask += (long) 1 << 31;
        final long[] result = new long[array.length];
        for (int i = 0; i < array.length; i++) {
            result[i] = mask & array[i];
        }
        return result;
    }
486843
public function getValue()
    {
        if (is_array($this->value)) {
            if (0 == count($this->value)) {
                return;
            } elseif (1 === count($this->value)) {
                return $this->value[0];
            } else {
                return $this->getRawMimeDirValue();
            }
        } else {
            return $this->value;
        }
    }
1112407
public function toArray()
	{
		$array = array ();
		for ($i=$this->interval->getStart(); $i<$this->interval->getEnd(); $i++)
		{
			$value = $this->getValue ($i);
			$array [$i] = $value;
		}
		return $array;
	}
329819
public function getParametersArray()
    {
        $result = parent::getParametersArray();

        if (!empty($this->getOffset())) {
            $result['offset'] = $this->getOffset();
        }

        if (!empty($this->getLimit())) {
            $result['limit'] = $this->getLimit();
        }

        if ($this->getTypes()->count() > 0) {
            $result['type'] = implode('|', $this->getTypes()->toArray());
        }

        if (!empty($this->getName())) {
            $result['f_name'] = $this->getName();
        }

        if (!empty($this->getCategoryID())) {
            $result['f_category'] = $this->getCategoryID();
        }

        if (!empty($this->getRepertoireID())) {
            $result['f_repertoire'] = $this->getRepertoireID();
        }

        if (!empty($this->getLocation())) {
            $result['f_location'] = $this->getLocation();
        }

        return $result;
    }
993580
public function get() {
		if ($this->active) $this->stop();

		foreach (array_keys($this->data) as $key) {
			$row =& $this->data[$key];
			$row['realtime_ms'] = $row['realtime']*1000;
			if (is_numeric($row['proctime'])) {
				$row['proctime_ms'] = $row['proctime']*1000;
			} else {
				$row['proctime_ms'] = 'n/a';
			}
		}

		$returner = $this->data;
		unset($this->data);
		
		return $returner;
	}
802953
public function getLength()
    {
        if ($this->getPagination() == self::BOOLEAN_TRUE) {
            $properties = $this->getProperties();
            return (array_key_exists('length', $properties) ? $properties['length'] : false);
        }
        return false;
    }
454319
public function getObjectLength()
    {
        $nrOfIdentifierOctets = strlen($this->getIdentifier());
        $contentLength = $this->getContentLength();
        $nrOfLengthOctets = $this->getNumberOfLengthOctets($contentLength);

        return $nrOfIdentifierOctets + $nrOfLengthOctets + $contentLength;
    }
828393
public function length(): float
    {
        if ($this->length === 0) {
            $this->length = $this->recomputeLength();
        }

        return $this->length;

    }
856045
public function getIntegralPart() : string
    {
        if ($this->scale === 0) {
            return $this->value;
        }

        $value = $this->getUnscaledValueWithLeadingZeros();

        return \substr($value, 0, -$this->scale);
    }
257586
public function getCondensed()
    {
        if ($this->version === 4) {
            return $this->value;
        }

        $addr = preg_replace('/(^|:)0+(\d)/', '\1\2', $this->getExpanded());

        if (preg_match_all('/(?:^|:)(?:0(?::|$))+/', $addr, $matches, PREG_OFFSET_CAPTURE)) {
            $max = 0;
            $pos = null;

            foreach ($matches[0] as $match) {
                if (strlen($match[0]) > $max) {
                    $max = mb_strlen($match[0]);
                    $pos = $match[1];
                }
            }

            $addr = substr_replace($addr, '::', $pos, $max);
        }

        return $addr;
    }
423047
public function getRawMimeDirValue()
    {
        $val = $this->getParts();

        if (isset($this->minimumPropertyValues[$this->name])) {
            $val = array_pad($val, $this->minimumPropertyValues[$this->name], '');
        }

        foreach ($val as &$item) {
            if (!is_array($item)) {
                $item = [$item];
            }

            foreach ($item as &$subItem) {
                $subItem = strtr(
                    $subItem,
                    [
                        '\\' => '\\\\',
                        ';' => '\;',
                        ',' => '\,',
                        "\n" => '\n',
                        "\r" => '',
                    ]
                );
            }
            $item = implode(',', $item);
        }

        return implode($this->delimiter, $val);
    }