Hola. Esto puedes lograrlo con clases o funciones recursivas (o redundantes, como les llamo yo)...

Un ejemplo en ASM:

proc numericalIncrement
 
    push bp
    push si
    push di
    push bx
    ;addr at        bp+18
    ;cnt init at    bp+16
    ;cnt max at     bp+14
    ;min at         bp+12
    ;max at         bp+10  
    mov bp, sp
    ;addr starts at  bp-2
    sub sp, 2
 
    mov si, ss:[bp+18]
    mov bx, ss:[bp+16]
 
    mov ax, ss:[bp+14]
    cmp ax, bx
    jz numericalIncrement_err0
    jmp numericalIncrement_stepOver0
    numericalIncrement_err0:
 
    mov ax, 0
    jmp numericalIncrement_return
 
    numericalIncrement_stepOver0:
 
    mov ax, ss:[bp+10]
    cmp al, byte ptr ss:[si+bx]
    jnz numericalIncrement_skip0
 
    mov al, byte ptr ss:[bp+12]
    mov byte ptr ss:[si+bx], al
 
    mov ax, ss:[bp+18]
    push ax
    mov ax, ss:[bp+16]
    inc ax ;next ch   
    push ax
    mov ax, ss:[bp+14]
    push ax
    mov ax, ss:[bp+12]
    push ax
    mov ax, ss:[bp+10]
    push ax
    call numericalIncrement
    pop ax
    jmp numericalIncrement_return
 
    numericalIncrement_skip0:
 
    mov al, byte ptr ss:[si+bx]
    inc al
    mov byte ptr ss:[si+bx], al
    mov ax, 1
 
    numericalIncrement_return:
    mov ss:[bp+18], ax
    mov sp, bp
    pop bx
    pop di
    pop si
    pop bp
 
    ret 2*4
endp
 

la funcion toma como parametros la cadena de variables, el valor minimo de la combinatoria, el valor maximo de la misma, el contador inicial en la cadena y el contador final de la misma respectivamente. Tambien la tengo en C; te la muestro en ASM porque fue la forma mas eficiente para mi de escribir el algoritmo...

Saludos.

---

Ah, y retorna en la pila 1 si fue efectiva o 0 si hubo un error (numericalIncrement_err0). Mas que incremento numerico creo que seria mejor llamada incremento combinatorial, pero el punto es el punto.

Aqui un ejemplo utilizando Windows, con una cadena de 4 variables byte (char) inicializada como 'a','a','a','a'. el minimo es el codigo ASCII del caracter 'a' y el maximo el respectivo al caracter 'z'; el inicio del contador es 0 y el maximo del mismo es 3:

https://i.imgur.com/k8EIqjG.png
https://i.imgur.com/WYk2uax.png

Dices; primero, aumento infinito de dos variables; luego, aumento de mas de dos. No son dos preguntas diferentes, es lo mismo; por tanto se aplica en este caso una funcion recursiva, es decir, que se llama a si misma, porque su "metodo" yace en si misma.

Supone una cadena de valores con un sistema numerico en base 3.
Supone una combinacion de tales cifras asi:

1,1,1

Aumento se define asi:

aumento (cadena_de_valores, valor_inicial, valor_final, contador_actual, contador_final)
{
si (cadena_de_valores[contador_actual] es menor o igual que valor_final) entonces
{
incrementar cadena_de_valores[contador_actual]
retornar contador_actual;
}
si no
{
aumento (cadena_de_valores, valor_inicial, valor_final, contador_actual+1, contador_final)
}
}

si ejecutas aumento con la cadena antes mencionada una vez (llamemosle a esas "veces" instantes), la cadena resultaria:

1,1,2

luego, entonces, de cada instante:

1,1,3
1,2,1
1,2,2
1,2,3
1,3,1
...

---

Por cierto, la llamada a la funcion del pseudocodigo seria de esta forma:

...
cadena=1,2,3
...
aumento (cadena, 1, 3, 0, 2)