VB.net Aiuto con funzione If then

[erot79]

Uso VB.net 2010 e FrameWork 4. Ho da risolvere la seguente questione: devo copiare gli elementi di un array 2-dimensionale A1(,) in un altro array A2(,) con "rango" A2 < A1 . Devo perciò copiare solo alcuni elementi a(i,j) dell'array A1 nell'array A2. Io conosco quali sono gli indici da non copiare, ma di volta in volta può variare il numero e la cifra. Mi servirebbe perciò capire come eseguire qualcosa del tipo

if i or j <> 1,3,7,... then    
'perciò tutti gli A1(1,x), A1(x,1),A1(3,x),A1(x,3),A1(7,x),A1(x,7) (con x variabile da 0 alla 'maxdim dell'array) saranno esclusi  
for i=0 to maxdim  
for j=0 to maxdim  
A2(i,j)=A1(i,j)  
next  
next  
end if

Il problema è perciò attribuire più condizioni if a i e j contemporaneamente. Io pensavo di inserire gli indici noti da escludere (1,3,7 ad es) in un array e trovare un modo per dire che i e j devono essere diversi da tutti i valori in esso contenuti. Non so se sia una cosa fattibile e spero di essermi spiegato bene. Grazie

[eziogsv]

     Dim Nums as integer = {1 , 3 ,.................}
     For i=0 to maxdim  
        For z=0 to Nums.Lenght -1
             if i=Nums(z) then goto 20
        Next
        For j=0 to maxdim 
             For K=0 to Nums.Lenght -1
                  if j=Nums(K) then goto 10
             Next
        A2(i,j)=A1(i,j)  
10     Next
20  Next

non lo ho provato, ma a lume di naso dovrebbe funzionare.... sempre se ho capito il problema

bye

[gibra]

Originariamente inviato da erot79
Uso VB.net 2010 e FrameWork 4. Ho da risolvere la seguente questione: devo copiare gli elementi di un array 2-dimensionale A1(,) in un altro array A2(,) con "rango" A2 < A1 . Devo perciò copiare solo alcuni elementi a(i,j) dell'array A1 nell'array A2. Io conosco quali sono gli indici da non copiare, ma di volta in volta può variare il numero e la cifra. Mi servirebbe perciò capire come eseguire qualcosa del tipo

Io farei così:

if i or j <> 1,3,7,... then    
'perciò tutti gli A1(1,x), A1(x,1),A1(3,x),A1(x,3),A1(7,x),A1(x,7) (con x variabile da 0 alla 'maxdim dell'array) saranno esclusi  
for i=0 to maxdim  
for j=0 to maxdim  
A2(i,j)=A1(i,j)  
next  
next  
end if

Il problema è perciò attribuire più condizioni if a i e j contemporaneamente. Io pensavo di inserire gli indici noti da escludere (1,3,7 ad es) in un array e trovare un modo per dire che i e j devono essere diversi da tutti i valori in esso contenuti. Non so se sia una cosa fattibile e spero di essermi spiegato bene. Grazie

For i=0 to maxdim  
    For j=0 to maxdim  
        Select Case True
            Case <indici_da_non_copiare)
                ' non copia
            Case Else
                A2(i,j) = A1(i,j)
         End Select
    Next
Next

Un esempio pratico:

' creo gli array e li valorizzo
Dim a1(4, 9) As Integer
Dim a2(4, 9) As Integer
Dim s As String = ""
Dim indiciDaNonCopiare As String = "1,3,7"
For i As Integer = 0 To 4
    For j As Integer = 0 To 9
        a1(i, j) = i + j
    Next
Next

' copia l'array a1 nell'array a2
For i As Integer = 0 To 4
    For j As Integer = 0 To 9
        Select Case True
            Case indiciDaNonCopiare.Contains(CStr(i)), indiciDaNonCopiare.Contains(CStr(j))
                ' non copiare
            Case Else
                a2(i, j) = a1(i, j)
                s = String.Format("{0}{1},{2}{3}", s, CStr(i), CStr(j), Environment.NewLine)
        End Select
    Next
Next

' mostra gli array copiati
MessageBox.Show(s)

[erot79]

Grazie a tutti della risposta. Il procedimento l'ho capito e alla fine avevo raggiunto anche io una soluzione analoga, solo che non va bene per il mio problema, ma è colpa mia perchè non mi son spiegato bene. Il problema sta nel fatto che non può essere A2(i,j)=A1(i,j). Nel senso che gli indici i,j da non considerare fanno si che nella A1(i,j) quelle righe/colonne vanno eliminate. Con riferimento alla immagine allegata,

[IMG] Uploaded with ImageShack.us[/IMG]

nonostante vengano esclusi correttamente gli elementi contenenti gli indici i e j (nell'immagine quelli corrispondenti alla riga/colonna 1 e 4), se io uso l'equivalenza A2(i,j)=A1(i,j) sbaglio perchè ad es l'elemento A2(2,2) dovrebbe essere uguale al A1(3,3) e non al A1(2,2).

Ho provato a sostituire A2(i,j)=A1(i,j) con il metodo array.copy(A1,A2,D x D) dove D è la dimensione della A2, ma il problema permane. Spero di essere stato più chiaro. Saluti

[gibra]

Allora devi ridimensionare il secondo array utilizzando dei contatori separati che si incrementano solo quando si esegue la copia dall'array di origine.

Tieni però presente che in un array a 2 dimensioni solo la seconda dimensione è 'ridimensionabile', ma la prima NO.
Per cui devi 'prima' analizzare l'array-origine per ricavare quanto grande deve essere la prima dimensione, poi potrai ridimensionare la seconda con Redim Preserve...

[erot79]

Ho capito, sembra molto più complicato di quanto credevo :-( , anche perchè a me il redim serve anche sulla prima dimensione. Trovo strano comunque che vb.net non permetta di gestire gli array come normali matrici matematiche, quindi consentire agevolmente l'eliminazione di una o più righe o colonne da una matrice originaria. Grazie lo stesso per il contributo, cercherò una soluzione alternativa

[oregon]

Originariamente inviato da erot79
Trovo strano comunque che vb.net non permetta di gestire gli array come normali matrici matematiche, quindi consentire agevolmente l'eliminazione di una o più righe o colonne da una matrice originaria.

A parte il fatto che nessun linguaggio consente di "sfilare" parti di array dalla memoria in modo automatico, non mi pare che neanche per le "matrici matematiche" si possa fare ... se non parliamo in modo astratto.

Quindi mi pare normale che ci sia bisogno di lavorarci un po' su (e comunque non mi sembra tanto difficile ...).

[rsdpzed]

se ti va di leggere in c# ti posto una soluzione. non ho capito se ti serve una soluzione "algoritmica" o "pratica". Questa è piu algoritmica ma ha come limitazione quella di dover allocare un array sufficientemente grande per gestire i risultati in quanto gli array puri come ha detto Oregon non si possono dimensonare a runtime.

private static int[,] Riduci(int[,] originale, int[] indici)
        {
            int[,] ridotto = new int[10, 10]; //uno sufficientemente grande.
            int count = 0;
            for (int i = 0; i < originale.GetLength(0); i++)
                for (int j = 0; j < originale.GetLength(1); j++)
                    if (!indici.Contains(i) && !indici.Contains(j))
                    {
                        int ri = count / (originale.GetLength(1) - indici.GetLength(0));
                        int rj = count % (originale.GetLength(1) - indici.GetLength(0));
                        ridotto[ri, rj] = originale[i, j];
                        count++;
                    }

            return ridotto;
        }

cosi la testi

int[,] originale = new int[5, 8];
            //inizializzo sequenzialmente
            for (int i = 0; i < originale.GetLength(0); i++)
            {
                for (int j = 0; j < originale.GetLength(1); j++)
                {
                    originale[i, j] = (i * originale.GetLength(1)) + j;
                    Console.Write(originale[i, j] + " - ");
                }
                Console.WriteLine();
            }

            int[] indici = { 0, 2, 4 }; //elenco indici da eliminare
            int[,] ridotto = Riduci(originale, indici);

            //output
            Console.WriteLine("Output matrice ridotta");
            for (int i = 0; i < originale.GetLength(0) - indici.GetLength(0); i++)
            {
                for (int j = 0; j < originale.GetLength(1) - indici.GetLength(0); j++)
                {
                    Console.Write(ridotto[i, j] + " - ");
                }
                Console.WriteLine();
            }

[erot79]

Beh sulle matrici in senso matematico avrei qualcosa da obiettare. Comunque ho risolto così: Copio gli elementi della matrice A1(r,c) in un datatable(r,c) e da esso in un datagridview(giusto per vedere se sto facendo bene), agisco su di esso eliminando le v-righe/colonne che di volta in volta ho necessità di escludere, gli elementi rimanenti li trasferisco in una nuova matrice A2(r-v,m-v). Ho provato con matrici 40x40 e il tutto risulta molto agevole e praticamente istantaneo. Ringrazio comunque per l'aiuto

[rsdpzed]

ottimo
Io come "esercizio domenicale" ho implementato una classe che risolve il problema con un taglio piu pratico. E' il metodo che ti ho suggerito qualche giorno fa nell'altro post.
L'ho tradotta in vb.net con il traduttore da c# ad occhio credo sia un buon traduttore .

''' <summary>
''' Rappresenta una matrice a due dimensioni. Fornisce un metodo per restituire un istanza ridotta attravrso gli indici da escludere.
''' </summary>
''' <typeparam name="T">Tipo di elementi contenuti nella matrice</typeparam>
Public Class MatriceRiducibile(Of T)
	'contenitore interno unidimensionale degli elementi
	Private elementi As List(Of T)

	''' <summary>
	''' Crea una nuova istanza della classe MatriceRiducibile
	''' </summary>
	''' <param name="righe">Dimensione 0 (righe)</param>
	''' <param name="colonne">Dimensione 1 (colonne)</param>
	Public Sub New(righe As Integer, colonne As Integer)
		Length0 = righe
		Length1 = colonne

		elementi = New List(Of T)()
	End Sub

	''' <summary>
	''' Restituisce la dimensione 0 (righe)
	''' </summary>
	Public Property Length0() As Integer
		Get
			Return m_Length0
		End Get
		Private Set
			m_Length0 = Value
		End Set
	End Property
	Private m_Length0 As Integer

	''' <summary>
	''' Restituisce la dimensione 1 (colonne)
	''' </summary>
	Public Property Length1() As Integer
		Get
			Return m_Length1
		End Get
		Private Set
			m_Length1 = Value
		End Set
	End Property
	Private m_Length1 As Integer

	''' <summary>
	''' Ottiene o imposta l'elemento agli indici specificati 
	''' </summary>
	''' <param name="r">Indice di riga</param>
	''' <param name="c">Indice di colonna</param>
	''' <exception cref="System.IndexOutOfRangeException"></exception>
	''' <exception cref="System.InvalidOperationException"></exception>
	''' <remarks>L'inserimento di nuovi elementi può avvenire solo in modo sequenziae</remarks>
	Public Default Property Item(r As Integer, c As Integer) As T
		Get
			'check sugli indici
			If r > Length0 OrElse c > Length1 Then
				Throw New IndexOutOfRangeException("indici fuori dimensione")
			End If

			'elemento non ancora inserito
			If r * Length1 + c > elementi.Count Then
				Return Nothing
			End If

			Return elementi.ElementAt(r * Length1 + c)
		End Get
		Set
			'check sugli indici
			If r > Length0 OrElse c > Length1 Then
				Throw New IndexOutOfRangeException("indici fuori dimensione")
			End If

			'elemento non ancora inserito
			If r * Length1 + c > elementi.Count Then
				Throw New InvalidOperationException("Elemento non modificabile")
			End If

			'gli indici corrispondono alla posizione del prossimo elemento quindi aggiungo...
			If r * Length1 + c = elementi.Count Then
				elementi.Add(value)
			Else
				'...altrimenti l'elemento è gia stato inserito quindi modifico
				elementi(r * Length1 + c) = value
			End If
		End Set
	End Property

	''' <summary>
	''' Restituisce una nuova istanza della classe MatriceRiducibile che contiene tutti gli elementi dell'oggetto corrente eccetto quelli i cui indici di riga o di colonna sono presenti nell'insieme di input
	''' </summary>
	''' <param name="indici">Insieme degli indici da escludere</param>
	''' <exception cref="System.ArgumentOutOfRangeException"></exception>
	Public Function Riduci(indici As Integer()) As MatriceRiducibile(Of T)
		If Not IndiciDiRiduzioneValidi(indici) Then
			Throw New ArgumentOutOfRangeException("L'insieme contiene indici non validi")
		End If

		Dim ridotta As New MatriceRiducibile(Of T)(Length0 - indici.GetLength(0), Length1 - indici.GetLength(0))

		Dim c As Integer = 0
		For i As Integer = 0 To Length0 - 1
			For j As Integer = 0 To Length1 - 1
				If Not indici.Contains(i) AndAlso Not indici.Contains(j) Then
					Dim ri As Integer = c \ ridotta.Length1
					Dim rj As Integer = c Mod ridotta.Length1
					ridotta(ri, rj) = Me(i, j)
					c += 1
				End If
			Next
		Next

		Return ridotta
	End Function

	Private Function IndiciDiRiduzioneValidi(indici As Integer()) As Boolean
		Return indici.All(Function(i) i <= Length0 AndAlso i <= Length1)
	End Function
End Class

"AndAlso"???? io smetterei di usare questo linguaggio solo per questo!