Is oibríocht bhunúsach san ailgéabar líneach é iolrú maitrís.
Bainimid úsáid as go ginearálta é i bhfeidhmchláir iomadúla mar phróiseáil íomhá, foghlaim meaisín, agus go leor eile. Is pacáiste Python suntasach é NumPy don ríomhaireacht eolaíoch.
Mar sin féin, sa phost seo, féachfaimid ar mhodhanna éagsúla chun iolrú maitrís a dhéanamh i Python gan NumPy a úsáid.
Bainfimid úsáid as lúb neadaithe, an fheidhm léarscáile ionsuite (), agus tuiscint liosta.
Ina theannta sin, féachfaimid ar na buntáistí agus na míbhuntáistí a bhaineann le gach straitéis, chomh maith le cathain is ceart gach ceann acu a chur i bhfeidhm. Má tá tú nua san ailgéabar líneach agus más mian leat níos mó a fhoghlaim faoi iolrú maitrís; lean ort ag léamh.
Cá Úsáidimid Iolrú Maitrís?
Úsáidtear iolrú maitrís i grafaicí ríomhaire chun amhairc 2T agus 3D a athrú. Mar shampla, is féidir leat rudaí ar an scáileán a rothlú, a scála agus a aistriú. Úsáidtear maitrísí i bpróiseáil íomhánna chun pictiúir a léiriú mar eagair de phicteilíní. Ina theannta sin, is féidir maitrísí a úsáid chun oibríochtaí cosúil le scagadh íomhá a dhéanamh.
Bainimid úsáid freisin as maitrísí i foghlaim meaisín. Is féidir leo cabhrú linn sonraí agus paraiméadair mhúnla a léiriú. Is féidir linn oibríochtaí iomadúla a dhéanamh, amhail táirgí poncanna ríomhaireachta agus táirgí veicteoir maitrís.
Cinnte, tá an oibríocht seo an-bhuntáisteach in oibríochtaí eolaíocha freisin. Is féidir linn é a úsáid san fhisic agus san innealtóireacht chun cur síos a dhéanamh ar chainníochtaí fisiceacha. Mar sin, is féidir linn oibriú le veicteoirí agus teanntóirí.
Cén Féidir Nach Roghnóimid NumPy a Úsáid?
Cé go bhfuil NumPy a Leabharlann Python, ní i gcónaí an rogha idéalach le haghaidh iolrú maitrís. Seans nach roghnóimid NumPy a úsáid ar chúiseanna mar mhéid agus spleáchas, foghlaim agus córais oidhreachta.
D'fhéadfadh sé a bheith níos éifeachtaí i gcásanna áirithe úsáid a bhaint as feidhmeanna ionsuite Python nó cód saincheaptha a fhorbairt. Tá sé ríthábhachtach a thabhairt faoi deara, áfach, gur leabharlann láidir í NumPy. Thairis sin, is féidir leat é a úsáid freisin le haghaidh iolrú maitrís.
Anois, déanaimis féachaint ar conas is féidir linn iolrú maitrís a bhaint amach gan NumPy.
Modh lúb neadaithe
Úsáideann teicníc na lúb neadaithe lúba neadaithe chun iolrú maitrís a dhéanamh i Python. Atriálann an fheidhm thar gach eilimint mhaitrís. Agus, iolraíonn sé iad ag baint úsáide as sraith de lúb neadaithe. Filleann an fheidhm an toradh, a stóráiltear i maitrís nua.
Is furasta an cur chuige seo a thuiscint. Mar sin féin, b'fhéidir nach mbeadh sé chomh héifeachtach le bealaí eile, go háirithe i gcás maitrísí níos mó. Mar sin féin, is rogha iontach é duit mura bhfuil tú nua don ailgéabar líneach.
def matrix_multiplication(A, B):
# Determine the matrices' dimensions.
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# Socraigh maitrís an toraidh go nialas.
result = [[0 for row in range(cols_B)] for col in
range(rows_A)]
# Iterate through rows of A
for s in range(rows_A):
# Iterate through columns of B
for j in range(cols_B):
# Iterate through rows of B
for k in range(cols_A):
result[s][j] += A[s][k] * B[k][j]
return result
Bíodh sampla againn de conas é seo a dhéanamh. Is féidir leat na línte cód seo a chur leis thíos chun an sampla seo a thástáil.
# Sample matrices
A = [[1, 4, 3], [4, 9, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Perform matrix multiplication
result = matrix_multiplication(A, B)
# Print the result
print(result)
# Output: [[76, 84], [175, 194]]
Sochair:
- Éasca a thuiscint.
- Great do newbies nó iad siúd atá ag lorg tuiscint níos doimhne ar iolrú maitrís.
Míbhuntáistí:
- Níl sé chomh héifeachtach le teicnící eile, go háirithe i gcás maitrísí níos mó.
- Níl sé chomh inléite le cur chuige malartach.
map() modh feidhme
Soláthraíonn modh feidhme map() cur chuige malartach chun iolrú maitrís a dhéanamh i Python. Sa chur chuige seo, úsáidimid an fheidhm léarscáil() ionsuite. Mar sin, úsáidimid uirlis ríomhchlárú feidhme a chuireann feidhm sholáthair i bhfeidhm ar gach eilimint inite (liosta, tuple, etc.). Chomh maith leis sin, glacann an fheidhm léarscáil() le dhá pharaiméadar, feidhm agus inathraithe. Agus, cuireann sé iterator ar ais a chuireann an fheidhm i bhfeidhm ar gach eilimint inite.
Sa chur chuige seo, téann muid trí gach ball den mhaitrís agus déanaimid an t-iolrú ag baint úsáide as an fheidhm mapa neadaithe().
Úsáidtear an fheidhm zip() chun atriall trí gach eilimint de na maitrísí i gcomhthreo.
Ar deireadh, úsáidtear an fheidhm suim() chun na torthaí a shuimiú.
def matrix_multiplication(A, B):
# To get the dimensions of the matrices
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# We use map() function for multiplication.
result = [[sum(a * b for a, b in zip(row_a, col_b)) for
col_b in zip(*B)] for row_a in A]
return result
Anois, arís, is féidir linn ár gcód a thástáil le sampla.
# Example matrices
A = [[3, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Use map() function to perform matrix multiplication
result = list(map(lambda x: list(map(lambda y: sum(i*j
for i,j in zip(x,y)), zip(*B))), A))
# Print the result
print(result)
# Output: [[72, 80], [139, 154]]
buntáistí
- Níos éifeachtaí ná cur chuige na lúb cruachta
- Úsáideann sé ríomhchlárú feidhmiúil chun an cód a dhéanamh níos simplí.
Míbhuntáistí
- D'fhéadfadh sé nach mbeadh sé chomh inléite ag daoine áirithe nach bhfuil cur amach acu ar ríomhchlárú feidhmiúil.
- Níl sé chomh intuigthe ná teicníc na lúb neadaithe.
Liosta modh tuisceana
Cuireann tuiscint liosta ar do chumas liosta nua a ghiniúint i líne amháin de chód. Mar sin, déantar é seo trí slonn a chur i bhfeidhm ar gach ball de liosta atá ann cheana féin.
Sa chur chuige seo, déantar an t-iolrú trí atriall arís agus arís eile trí gach ball maitrís. Táimid ag baint úsáide as tuiscint liostaí sraitheach.
# Sample matrices
A = [[1, 12, 3], [14, 5, 6]]
B = [[7, 8], [9, 10], [12, 12]]
# Matrix multiplication using list comprehension
result = [[sum(A[i][k] * B[k][j] for k in range(len(A[0])))
for j in range(len(B[0]))] for i in range(len(A))]
# Print the result
print(result)
[[151, 164], [215, 234]]
Sochair
- I gcomparáid leis an modh feidhme map(), tá sé níos giorra agus níos inléite.
Míbhuntáistí
- D’fhéadfadh sé a bheith níos lú éifeachtaí ná an fheidhm map() a úsáid, go háirithe i gcás maitrísí móra.
- Tá sé níos deacra ná cur chuige na lúb neadaithe.
Conclúid
Sa phost seo, d'fhéachamar ar roghanna eile seachas NumPy a úsáid agus maitrísí á iolrú i Python. Rinneamar iolrú maitrís i lúba neadaithe, an fheidhm léarscáile () ionsuite, agus tuiscint liostaí.
Beidh an straitéis is fearr ag brath ar riachtanais ar leith do thionscadal.
Tá buntáistí agus míbhuntáistí dá chuid féin ag gach ceann de na straitéisí. Chun a chinntiú go bhfuil an fheidhm ag feidhmiú i gceart, is smaoineamh maith é roinnt cásanna tástála a chur leis le toisí agus luachanna maitrís éagsúla.
Ba cheart duit roinnt tástálacha feidhmíochta a chur san áireamh freisin chun comparáid a dhéanamh ar chomh maith agus a fheidhmíonn na modhanna seo.
Leave a Reply