Programación D - Rangos
Los rangos son una abstracción del acceso a elementos. Esta abstracción permite el uso de un gran número de algoritmos sobre un gran número de tipos de contenedores. Los rangos enfatizan cómo se accede a los elementos del contenedor, a diferencia de cómo se implementan los contenedores. Rangos es un concepto muy simple que se basa en si un tipo define ciertos conjuntos de funciones miembro.
Los rangos son una parte integral de los cortes de D. D resulta que son implementaciones del rango más poderoso RandomAccessRange, y hay muchas características de rango en Phobos. Muchos algoritmos de Phobos devuelven objetos de rango temporal. Por ejemplo, filter () elige elementos que son mayores que 10 en el siguiente código en realidad devuelve un objeto de rango, no una matriz.
Rangos de números
Los rangos de números se utilizan con bastante frecuencia y estos rangos de números son de tipo int. A continuación se muestran algunos ejemplos de rangos de números:
// Example 1
foreach (value; 3..7)
// Example 2
int[] slice = array[5..10];Rangos de Phobos
Los rangos relacionados con estructuras e interfaces de clase son rangos de fobos. Phobos es la biblioteca estándar y en tiempo de ejecución oficial que viene con el compilador de lenguaje D.
Hay varios tipos de rangos que incluyen:
- InputRange
- ForwardRange
- BidirectionalRange
- RandomAccessRange
- OutputRange
Rango de entrada
El rango más simple es el rango de entrada. Las otras gamas traen más requisitos además de la gama en la que se basan. Hay tres funciones que requiere InputRange:
empty- Especifica si el rango está vacío; debe devolver verdadero cuando se considera que el rango está vacío; falso de lo contrario.
front - Proporciona acceso al elemento al principio del rango.
popFront() - Acorta el rango desde el principio quitando el primer elemento.
Ejemplo
import std.stdio;
import std.string;
struct Student {
string name;
int number;
string toString() const {
return format("%s(%s)", name, number);
}
}
struct School {
Student[] students;
}
struct StudentRange {
Student[] students;
this(School school) {
this.students = school.students;
}
@property bool empty() const {
return students.length == 0;
}
@property ref Student front() {
return students[0];
}
void popFront() {
students = students[1 .. $];
}
}
void main() {
auto school = School([ Student("Raj", 1), Student("John", 2), Student("Ram", 3)]);
auto range = StudentRange(school);
writeln(range);
writeln(school.students.length);
writeln(range.front);
range.popFront;
writeln(range.empty);
writeln(range);
}Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
[Raj(1), John(2), Ram(3)]
3
Raj(1)
false
[John(2), Ram(3)]ForwardRange
ForwardRange además requiere la parte de función miembro de guardar de las otras tres funciones de InputRange y devolver una copia del rango cuando se llama a la función de guardar.
import std.array;
import std.stdio;
import std.string;
import std.range;
struct FibonacciSeries {
int first = 0;
int second = 1;
enum empty = false; // infinite range
@property int front() const {
return first;
}
void popFront() {
int third = first + second;
first = second;
second = third;
}
@property FibonacciSeries save() const {
return this;
}
}
void report(T)(const dchar[] title, const ref T range) {
writefln("%s: %s", title, range.take(5));
}
void main() {
auto range = FibonacciSeries();
report("Original range", range);
range.popFrontN(2);
report("After removing two elements", range);
auto theCopy = range.save;
report("The copy", theCopy);
range.popFrontN(3);
report("After removing three more elements", range);
report("The copy", theCopy);
}Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
Original range: [0, 1, 1, 2, 3]
After removing two elements: [1, 2, 3, 5, 8]
The copy: [1, 2, 3, 5, 8]
After removing three more elements: [5, 8, 13, 21, 34]
The copy: [1, 2, 3, 5, 8]BidirectionalRange
BidirectionalRange además proporciona dos funciones miembro sobre las funciones miembro de ForwardRange. La función trasera, similar a la delantera, permite acceder al último elemento de la gama. La función popBack es similar a la función popFront y elimina el último elemento del rango.
Ejemplo
import std.array;
import std.stdio;
import std.string;
struct Reversed {
int[] range;
this(int[] range) {
this.range = range;
}
@property bool empty() const {
return range.empty;
}
@property int front() const {
return range.back; // reverse
}
@property int back() const {
return range.front; // reverse
}
void popFront() {
range.popBack();
}
void popBack() {
range.popFront();
}
}
void main() {
writeln(Reversed([ 1, 2, 3]));
}Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
[3, 2, 1]Rango de acceso aleatorio infinito
opIndex () es adicionalmente necesario en comparación con ForwardRange. Además, el valor de una función vacía que se conocerá en tiempo de compilación como falso. A continuación se muestra un ejemplo simple que se explica con el rango de cuadrados.
import std.array;
import std.stdio;
import std.string;
import std.range;
import std.algorithm;
class SquaresRange {
int first;
this(int first = 0) {
this.first = first;
}
enum empty = false;
@property int front() const {
return opIndex(0);
}
void popFront() {
++first;
}
@property SquaresRange save() const {
return new SquaresRange(first);
}
int opIndex(size_t index) const {
/* This function operates at constant time */
immutable integerValue = first + cast(int)index;
return integerValue * integerValue;
}
}
bool are_lastTwoDigitsSame(int value) {
/* Must have at least two digits */
if (value < 10) {
return false;
}
/* Last two digits must be divisible by 11 */
immutable lastTwoDigits = value % 100;
return (lastTwoDigits % 11) == 0;
}
void main() {
auto squares = new SquaresRange();
writeln(squares[5]);
writeln(squares[10]);
squares.popFrontN(5);
writeln(squares[0]);
writeln(squares.take(50).filter!are_lastTwoDigitsSame);
}Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
25
100
25
[100, 144, 400, 900, 1444, 1600, 2500]Rango de acceso aleatorio finito
opIndex () y la longitud son también obligatorios en comparación con el rango bidireccional. Esto se explica con la ayuda de un ejemplo detallado que utiliza la serie de Fibonacci y el ejemplo de Squares Range utilizado anteriormente. Este ejemplo funciona bien en el compilador D normal, pero no en el compilador en línea.
Ejemplo
import std.array;
import std.stdio;
import std.string;
import std.range;
import std.algorithm;
struct FibonacciSeries {
int first = 0;
int second = 1;
enum empty = false; // infinite range
@property int front() const {
return first;
}
void popFront() {
int third = first + second;
first = second;
second = third;
}
@property FibonacciSeries save() const {
return this;
}
}
void report(T)(const dchar[] title, const ref T range) {
writefln("%40s: %s", title, range.take(5));
}
class SquaresRange {
int first;
this(int first = 0) {
this.first = first;
}
enum empty = false;
@property int front() const {
return opIndex(0);
}
void popFront() {
++first;
}
@property SquaresRange save() const {
return new SquaresRange(first);
}
int opIndex(size_t index) const {
/* This function operates at constant time */
immutable integerValue = first + cast(int)index;
return integerValue * integerValue;
}
}
bool are_lastTwoDigitsSame(int value) {
/* Must have at least two digits */
if (value < 10) {
return false;
}
/* Last two digits must be divisible by 11 */
immutable lastTwoDigits = value % 100;
return (lastTwoDigits % 11) == 0;
}
struct Together {
const(int)[][] slices;
this(const(int)[][] slices ...) {
this.slices = slices.dup;
clearFront();
clearBack();
}
private void clearFront() {
while (!slices.empty && slices.front.empty) {
slices.popFront();
}
}
private void clearBack() {
while (!slices.empty && slices.back.empty) {
slices.popBack();
}
}
@property bool empty() const {
return slices.empty;
}
@property int front() const {
return slices.front.front;
}
void popFront() {
slices.front.popFront();
clearFront();
}
@property Together save() const {
return Together(slices.dup);
}
@property int back() const {
return slices.back.back;
}
void popBack() {
slices.back.popBack();
clearBack();
}
@property size_t length() const {
return reduce!((a, b) => a + b.length)(size_t.init, slices);
}
int opIndex(size_t index) const {
/* Save the index for the error message */
immutable originalIndex = index;
foreach (slice; slices) {
if (slice.length > index) {
return slice[index];
} else {
index -= slice.length;
}
}
throw new Exception(
format("Invalid index: %s (length: %s)", originalIndex, this.length));
}
}
void main() {
auto range = Together(FibonacciSeries().take(10).array, [ 777, 888 ],
(new SquaresRange()).take(5).array);
writeln(range.save);
}Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 777, 888, 0, 1, 4, 9, 16]Rango de salida
OutputRange representa la salida del elemento transmitido, similar al envío de caracteres a stdout. OutputRange requiere soporte para la operación put (rango, elemento). put () es una función definida en el módulo std.range. Determina las capacidades del rango y el elemento en el tiempo de compilación y utiliza el método más apropiado para generar los elementos. A continuación se muestra un ejemplo sencillo.
import std.algorithm;
import std.stdio;
struct MultiFile {
string delimiter;
File[] files;
this(string delimiter, string[] fileNames ...) {
this.delimiter = delimiter;
/* stdout is always included */
this.files ~= stdout;
/* A File object for each file name */
foreach (fileName; fileNames) {
this.files ~= File(fileName, "w");
}
}
void put(T)(T element) {
foreach (file; files) {
file.write(element, delimiter);
}
}
}
void main() {
auto output = MultiFile("\n", "output_0", "output_1");
copy([ 1, 2, 3], output);
copy([ "red", "blue", "green" ], output);
}Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
[1, 2, 3]
["red", "blue", "green"]