দু'জনের বেশি আর্গুমেন্টের জন্য নম্পু `লজিক্যাল_অর

Question 1

নম্পির logical_orফাংশন তুলনায় দুটি অ্যারের বেশি লাগে না। আমি কীভাবে দুটির বেশি অ্যারের মিল খুঁজে পাব? (নম্প্পির ক্ষেত্রে এবং দুটিরও logical_andবেশি অ্যারের ছেদ প্রাপ্তির ক্ষেত্রে একই প্রশ্ন জিজ্ঞাসা করা যেতে পারে ))

Question 2

যদি আপনি এটি সম্পর্কে জিজ্ঞাসা করছেন numpy.logical_or, তবে না, ডক্স যেমন স্পষ্টভাবে বলেছে, কেবলমাত্র পরামিতিগুলি x1, x2এবং allyচ্ছিকভাবে out:

numpy.logical_or( x1, x2[, out]) =<ufunc 'logical_or'>

আপনি অবশ্যই একাধিক logical_orকল একসাথে চেইন করতে পারেন :

>>> x = np.array([True, True, False, False])
>>> y = np.array([True, False, True, False])
>>> z = np.array([False, False, False, False])
>>> np.logical_or(np.logical_or(x, y), z)
array([ True,  True,  True,  False], dtype=bool)

নুমপাইতে এই ধরণের চেইন জেনারালাইজ করার উপায় সহ reduce:

>>> np.logical_or.reduce((x, y, z))
array([ True,  True,  True,  False], dtype=bool)

এবং অবশ্যই এটি কাজ করবে যদি আপনার পৃথক অ্যারেগুলির পরিবর্তে একাধিক মাত্রিক অ্যারে থাকে — আসলে, এটি ব্যবহার করার জন্য কীভাবে বোঝানো হয়েছে:

>>> xyz = np.array((x, y, z))
>>> xyz
array([[ True,  True, False, False],
       [ True, False,  True, False],
       [False, False, False, False]], dtype=bool)
>>> np.logical_or.reduce(xyz)
array([ True,  True,  True,  False], dtype=bool)

তবে তিনটি সমান দৈর্ঘ্যের 1D অ্যারেগুলির একটি টিপলটি NumPy পদগুলিতে অ্যারে_ লাইক হয় এবং এটি 2D অ্যারে হিসাবে ব্যবহার করা যেতে পারে।

নামপির বাইরেও আপনি পাইথন ব্যবহার করতে পারেন reduce:

>>> functools.reduce(np.logical_or, (x, y, z))
array([ True,  True,  True,  False], dtype=bool)

তবে, নম্পপি'র মতো নয় reduce, পাইথনের প্রায়শই প্রয়োজন হয় না। বেশিরভাগ ক্ষেত্রে, কাজ করার একটি সহজ উপায় রয়েছে — যেমন একাধিক পাইথন orঅপারেটরকে একসাথে চেইন করা , reduceশেষ না করা operator.or_, কেবল ব্যবহার any। এবং যখন সেখানে থাকে না , এটি সাধারণত একটি স্পষ্ট লুপ ব্যবহার করার জন্য আরও পঠনযোগ্য।

এবং প্রকৃতপক্ষে NumPy এর anyক্ষেত্রেও এই ক্ষেত্রে ব্যবহার করা যেতে পারে, যদিও এটি ততটা তুচ্ছ নয়; যদি আপনি এটিকে স্পষ্টভাবে একটি অক্ষর না দেন তবে আপনি অ্যারের পরিবর্তে একটি স্ক্যালার দিয়ে শেষ করবেন। সুতরাং:

>>> np.any((x, y, z), axis=0)
array([ True,  True,  True,  False], dtype=bool)

যেমনটি আপনি প্রত্যাশা করতে পারেন, logical_andঅনুরূপ — আপনি এটি শৃঙ্খলাবদ্ধ করতে পারেন, np.reduceএটি, functools.reduceএটি, বা allএকটি স্পষ্টরূপে প্রতিস্থাপন করতে পারেন axis।

যেমন অন্যান্য অপারেশন সম্পর্কে logical_xor? আবার, একই চুক্তি ... এই ক্ষেত্রে ব্যতীত কোনও all/ any-টাইপ ফাংশন নেই । (আপনি এটাকে কী বলবেন odd??)

Question 3

বলুন আপনি তিনটি বুলিয়ান অ্যারে আছে - যদি কেউ এখনও এই প্রয়োজন a, b, cএকই আকৃতি সঙ্গে, এই দেয় and: উপাদান-অনুযায়ী

a * b * c

এটি দেয় or:

a + b + c

এই কমান্ডের সাহায্যে আপনি চান কি? প্রচুর পরিমাণে স্ট্যাক করা logical_andবা logical_orব্যবহারিক নয়।

Question 4

যেহেতু বুলিয়ান বীজগণিত সংজ্ঞা অনুসারে উভয়ই পরিবর্তনশীল এবং সহযোগী হয়, নীচের বিবৃতিগুলি a, b এবং c এর বুলিয়ান মানগুলির সমতুল্য ।

a or b or c

(a or b) or c

a or (b or c)

(b or a) or c

সুতরাং আপনার যদি একটি "লজিকাল_অর" থাকে যা ডায়াডিক এবং আপনার এটির তিনটি আর্গুমেন্ট (ক, খ এবং সি) পাস করার প্রয়োজন হয়, আপনি কল করতে পারেন

logical_or(logical_or(a, b), c)

logical_or(a, logical_or(b, c))

logical_or(c, logical_or(b, a))

বা যাই হোক না কেন আপনার অনুমতি পছন্দ।

testঅজগরটিতে ফিরে যান, আপনি যদি শর্তটি পরীক্ষা করতে চান যে কোনও শর্ত (একটি ফাংশন দ্বারা উত্পাদিত যা বুলিয়ান মান দেয়) একটি বা বি বা সি বা তালিকার এলের কোনও উপাদানের ক্ষেত্রে প্রযোজ্য কিনা আপনি সাধারণত ব্যবহার করেন

any(test(x) for x in L)

Question 5

এন-ডাইমেনশনাল কেসের জন্য অবার্ন্টের উত্তরের উপর ভিত্তি করে তৈরি করা:

টিএল; ডিআর: np.logical_or.reduce(np.array(list))

Question 6

যোগফলটি ব্যবহার করে:

a = np.array([True, False, True])
b = array([ False, False,  True])
c = np.vstack([a,b,b])

Out[172]: 
array([[ True, False,  True],
   [False, False,  True],
   [False, False,  True]], dtype=bool)

np.sum(c,axis=0)>0
Out[173]: array([ True, False,  True], dtype=bool)

Question 7

আমি এই কাজটি ব্যবহার করছি যা এন অ্যারেতে বাড়ানো যেতে পারে:

>>> a = np.array([False, True, False, False])
>>> b = np.array([True, False, False, False])
>>> c = np.array([False, False, False, True])
>>> d = (a + b + c > 0) # That's an "or" between multiple arrays
>>> d
array([ True,  True, False,  True], dtype=bool)

Question 8

আমি নিম্নলিখিত তিনটি ভিন্ন পদ্ধতি চেষ্টা করেছি পেতে logical_andতালিকার ঠ এর ট আকারের অ্যারে এন :

একটি পুনরাবৃত্ত ব্যবহার করে numpy.logical_and(নীচে দেখুন)
ব্যবহার numpy.logical_and.reduce(l)
ব্যবহার numpy.vstack(l).all(axis=0)

তারপর আমি logical_orফাংশন জন্য একই কাজ। আশ্চর্যজনকভাবে যথেষ্ট, পুনরাবৃত্তির পদ্ধতিটি দ্রুততম।

import numpy
import perfplot

def and_recursive(*l):
    if len(l) == 1:
        return l[0].astype(bool)
    elif len(l) == 2:
        return numpy.logical_and(l[0],l[1])
    elif len(l) > 2:
        return and_recursive(and_recursive(*l[:2]),and_recursive(*l[2:]))

def or_recursive(*l):
    if len(l) == 1:
        return l[0].astype(bool)
    elif len(l) == 2:
        return numpy.logical_or(l[0],l[1])
    elif len(l) > 2:
        return or_recursive(or_recursive(*l[:2]),or_recursive(*l[2:]))

def and_reduce(*l):
    return numpy.logical_and.reduce(l)

def or_reduce(*l):
    return numpy.logical_or.reduce(l)

def and_stack(*l):
    return numpy.vstack(l).all(axis=0)

def or_stack(*l):
    return numpy.vstack(l).any(axis=0)

k = 10 # number of arrays to be combined

perfplot.plot(
    setup=lambda n: [numpy.random.choice(a=[False, True], size=n) for j in range(k)],
    kernels=[
        lambda l: and_recursive(*l),
        lambda l: and_reduce(*l),
        lambda l: and_stack(*l),
        lambda l: or_recursive(*l),
        lambda l: or_reduce(*l),
        lambda l: or_stack(*l),
    ],
    labels = ['and_recursive', 'and_reduce', 'and_stack', 'or_recursive', 'or_reduce', 'or_stack'],
    n_range=[2 ** j for j in range(20)],
    logx=True,
    logy=True,
    xlabel="len(a)",
    equality_check=None
)

এখানে কে = 4 এর পারফরম্যান্স নীচে।

এবং এখানে কে = 10 এর পারফরম্যান্সের নীচে।

দেখে মনে হচ্ছে উচ্চতর এন এর জন্য প্রায় ধ্রুবক সময় ওভারহেড রয়েছে।