
Closed
Posted
I’m working on a personal project that leans heavily on SymPy, and I’ve hit a limitation with the way the library handles division when both operands are integers. What I need is a clean modification to SymPy’s source so I can keep every operation strictly in the integer domain—avoiding automatic promotion to Rational objects—while preserving all of SymPy’s usual behaviour for non-integer or mixed-type inputs. Here’s what the job entails: • Identify the precise spot in SymPy’s core (likely sympy/core/[login to view URL] or related) where integer division is resolved. • Implement a path that returns the floor-divided Integer result (e.g. 7/3 → 2) or, if you prefer, expose a switch/flag or subclass that activates this behaviour only when requested so the standard API remains intact for most users. • Maintain compatibility with SymPy’s assumptions system and ensure no regressions elsewhere; all existing unit tests must still pass. • Supply your own focused test cases that demonstrate the new integer-division logic and show that speed or memory footprint is at least on par with the original code. • Deliverables: a patch (or fork/branch) ready to merge, plus a short demo script that I can run immediately. I’ll review by running SymPy’s full test suite along with your additional tests. If everything is green and the demo behaves exactly as described, the milestone is complete.
Project ID: 40688775
78 proposals
Remote project
Active 1 min ago
Set your budget and timeframe
Get paid for your work
Outline your proposal
It's free to sign up and bid on jobs
78 freelancers are bidding on average $19 USD/hour for this job

Hello, SYMPY INTEGER DIVISION ENHANCEMENT {{{ I HAVE WORKED ON SIMILAR PYTHON LIBRARY AND CORE LOGIC MODIFICATIONS BEFORE, AND I CAN SHOW YOU RELEVANT WORK }}} I have carefully reviewed your requirements and understand the need to modify SymPy's integer division behaviour while preserving standard behaviour for non-integer and mixed-type inputs. I have 11+ years of experience in Python, mathematical libraries, core framework development, source-code modification and automated testing. I can trace the relevant SymPy core implementation, add a controlled integer-domain division path, maintain compatibility with the assumptions system and avoid regressions across existing functionality. I will provide a clean merge-ready patch/branch, focused unit tests, performance/memory validation and a simple demo script. I will also run the relevant SymPy test suite to ensure existing behaviour remains stable outside the requested integer path. I WILL PROVIDE 2 YEARS OF FREE ONGOING SUPPORT AND COMPLETE SOURCE CODE. Thanks, Christina
$15 USD in 40 days
6.9
6.9

Hi, ★★★ Python Specialist ★★★ I understand the need to modify SymPy for integer division without promoting to Rational objects. I will first locate the integer division handling in sympy/core/numbers.py. Then, I will implement a solution that ensures integer results using floor division, while keeping the existing API intact for other types. To maintain compatibility with SymPy's assumptions, I will ensure that all unit tests pass and create additional focused tests to validate the new logic. I will also provide a demo script for immediate testing. To get started, I will need access to the current version of SymPy you are using and any specific requirements for the tests you want to see. Thanks!
$20 USD in 40 days
7.1
7.1

Hi, I can implement this as an explicit, opt-in integer-division path rather than changing `Integer.__truediv__` globally. Replacing SymPy’s standard `Integer / Integer -> Rational` behaviour would alter fundamental algebraic semantics and cannot realistically preserve the existing test suite unchanged. I recommend a dedicated `IntegerFloorDiv` expression or helper that returns an `Integer` when both operands are concrete integers, respects symbolic assumptions, and delegates to normal SymPy division for mixed or non-integer inputs. Symbolic cases can remain unevaluated until assumptions prove integer operands and a nonzero divisor. The patch will include focused tests for positive and negative operands, zero division, symbolic integers, mixed numeric types, simplification, substitution, serialization, and performance. I’ll also run the relevant core tests before the full suite and provide a standalone demonstration script and concise design notes. Should negative division follow mathematical floor semantics (`-7/3 -> -3`) or truncation toward zero (`-7/3 -> -2`)? Regards, Houssame
$20 USD in 40 days
6.9
6.9

Hello there. I hope you are donig well. I have successfully worked on projects requiring deep modifications to mathematical libraries, focusing on maintaining core functionality while introducing new features. My background in Python and algorithm design equips me with the skills to enhance SymPy effectively. I understand that the goal is to modify SymPy's integer division handling to prevent automatic promotion to Rational objects. I will identify the appropriate section in the library and implement a clean solution to ensure operations remain strictly in the integer domain, while ensuring compatibility with existing functionality. I will deliver a high-quality patch ready for merging, along with custom test cases to validate the new integer division logic. My approach will prioritize performance and memory efficiency, ensuring that the solution meets your expectations and integrates seamlessly into your project. Please feel free to reach out to me. I look forward to working with you. Best regards, Billy Bryan
$20 USD in 40 days
4.8
4.8

==== Hi - Truong here ==== "SYMPY INTEGER DIVISION" — you need integer operands to produce floor-divided Integer results without changing SymPy’s normal behavior for other inputs. I’d trace the division path in SymPy’s core, implement the integer-only behavior behind a safe switch or isolated path, and preserve assumptions and mixed-type handling. I’ll add focused regression/performance tests, run the full test suite, and provide a merge-ready patch with a runnable demo. Do you want `7/3` to return `Integer(2)` globally for integer operands, or only when an explicit mode/flag is enabled? Looking forward to work with you
$20 USD in 40 days
4.9
4.9

Hi, your goal is clear: keep SymPy arithmetic in the integer domain when both inputs are integers, without disturbing normal behaviour elsewhere. I’ve worked on Python library patches and test-driven changes in core numeric code, including careful updates that preserve assumptions and existing APIs. For this, I’d trace the division path in SymPy’s core, add the integer-only branch or opt-in switch cleanly, and then validate it against the full suite plus targeted regression tests. I’d keep the change minimal, document the new behaviour, and include a small demo script showing the integer result path in action. I’ll also check that performance stays aligned with the current implementation. If that sounds right, I’m ready to start. Best regards, Gabriel
$25 USD in 19 days
4.6
4.6

I can rebuild SymPy's integer division at the C level using GMP for the heavy lifting, then wrap it back into the Python layer so your existing code keeps working. Should take about 4 days. These numbers are based on the post as written, we will refine them once we go over the actual bottleneck together. Want to jump on a quick call?
$25 USD in 5 days
4.0
4.0

Hi, I’ve read your SymPy integer-division requirement carefully, and I’m confident I can implement this cleanly without disturbing standard behaviour. I can trace the exact resolution path in SymPy’s core, add an opt-in branch/flag or subclass for Integer-only division semantics, and preserve assumptions compatibility while keeping mixed-type handling untouched. My experience in Python-based software development and architecture is well aligned with source-level library customization, regression-safe patching, and test-driven delivery. I’ll provide a merge-ready patch or branch, focused unit tests covering the new logic, performance checks against the current path, and a demo script so you can validate 7/3 → 2 behavior immediately. I can start right away and deliver the first working patch for review within 1-2 days, followed by test-suite validation and refinements. Would you prefer this integer-division behavior exposed as an opt-in flag, a subclass, or a minimal core patch? Best regards, KANIKA
$22 USD in 30 days
4.0
4.0

Hi there, Encountering limitations with libraries like SymPy can be frustrating, especially when integer division defaults to unexpected types. To address this, I can modify SymPy's core to ensure all integer divisions remain in the integer domain, preserving its behaviour for non-integer inputs. This will include either implementing a switch to toggle this feature or creating a subclass, ensuring compatibility and maintaining performance. Here are my questions: Which version of SymPy are you currently using? Also, do you prefer a built-in flag for toggling this behaviour, or should it remain a separate subclass? Drop me a message so we can get started right away.
$15 USD in 40 days
3.4
3.4

Hello, Having worked as a full-stack developer for the past 15+ years, I have an in-depth understanding of not only multiple programming languages but also the entire software development lifecycle. This profound knowledge includes designing, debugging, and enhancing codebases just like SymPy that you need support with. Although most of my career has been centered around web, mobile, and custom software development, I have a solid grasp of C programming and C++ which will be crucial for enhancing SymPy's integer division capabilities. In terms of project requirements, I am experienced in navigating and making modifications in large codebases while ensuring compatibility with existing systems. Moreover, my proficiency with cloud infrastructure in general and AWS specifically, along with CI/CD techniques, will help me provide you with a deliverable that's compatible with your existing setup and ready to merge without facing any downtime to your operations. Additionally, throughout my career I have placed emphasis on writing efficient code that guarantees optimal performance. By implementing the requested enhancements to SymPy, I assure you any speed or memory impact will be conscionable and consistent with the original code. Given my experience with clean coding practices and maintaining high-quality standards - evidenced by my portfolio - let's leverage these skills to get your project successfully across the finish line! Thanks!
$20 USD in 21 days
3.4
3.4

You want integer division to stay integers, like 7/3 becoming 2, without changing how mixed or non-integer math works. I can start right now. I will add a switch so this only turns on when you want it, keep every existing test passing, and add focused tests of my own. You get a live working sample in 24-48 hours: the patch, a short demo, and proof the old behaviour is still intact. Shall I start with that sample so you can try 7/3 yourself?
$18 USD in 2 days
3.2
3.2

Hello!! The project needs a controlled SymPy core modification so integer division can return an Integer floor result without automatic Rational promotion, while preserving normal behaviour for mixed or non-integer inputs. * Which SymPy version are you currently using? * Would you prefer a switch or a separate subclass for this behaviour? * Do you already have expected edge cases for negative integers? The relevant SymPy internals will be traced carefully, with the integer-only path isolated so the standard API and assumptions system remain safe. Focused tests, performance and memory checks, the full existing test suite, a merge-ready patch and a runnable demo script will be provided. Relevant Python, mathematical logic, library modification and testing projects have been handled with strong attention to clean core-level changes and avoiding regressions. Happy to review your current SymPy setup and implement this cleanly. Best regards Farhin B
$16 USD in 40 days
2.9
2.9

I’ll first trace SymPy’s integer-division flow through the core number classes and identify the exact point where two Integer operands are promoted to Rational. I’ll then implement an isolated floor-division path so 7/3 can produce Integer(2) while preserving SymPy’s existing behavior for Rational, Float, Symbol, and mixed-type inputs. I’ll design the change to minimize impact on the standard API, preferably using an explicit opt-in mechanism if changing / globally could introduce compatibility issues. I’ll also verify that assumptions, canonicalization, hashing, evaluation, and printing remain consistent with normal SymPy Integer objects. I’ll add focused regression tests covering exact integer pairs, negative values, zero division, mixed numeric types, unevaluated expressions, and interactions with assumptions. I’ll run the relevant core-number tests first and then the full SymPy test suite to catch regressions outside the modified code. For performance, I’ll benchmark representative integer divisions against the existing implementation and check object allocation/memory behavior so the new path does not introduce unnecessary overhead. I’ll also review edge cases such as Python integer interoperability and SymPy’s evaluation conventions.
$20 USD in 40 days
2.7
2.7

I would avoid changing SymPy Integer.__truediv__ globally, because that would break core symbolic semantics and many existing tests. A safer design is an explicit subclass, wrapper, or opt-in function/context that performs floor division only when both operands are confirmed Integers and delegates every mixed or symbolic case to standard SymPy behaviour. I can trace the dispatch path, implement the isolated behaviour, add focused and regression tests, benchmark it, and provide a clean patch plus demo script. Please confirm the target SymPy version and whether an upstreamable API is required.
$25 USD in 15 days
2.1
2.1

Hi, I can modify SymPy’s core integer-division handling with a clean, isolated implementation that preserves standard behaviour for non-integer and mixed-type inputs. I’ll add focused tests for floor-divided Integer results, assumptions compatibility, regressions, and performance/memory comparison, then provide a merge-ready patch/fork and a runnable demo script after validating against the full test suite. 1. Should the integer-division behaviour be opt-in via a flag/subclass, or should it replace the default `Integer / Integer` behaviour globally? 2. Which SymPy version/commit should the patch target, and do you have a preferred Python version for the test environment?
$20 USD in 40 days
1.6
1.6

Hi I can modify SymPy’s integer division path so integer operands can return the floor-divided `Integer` result without affecting Rational behavior for mixed or non-integer inputs. I’ll keep the change isolated, compatible with assumptions and existing APIs, add focused regression/performance tests, run the relevant/full test suite, and provide a merge-ready patch with a simple demo script. I’m sure I can deliver a perfect result within timeline as your wanna. I’d be happy to jump on a quick chat to discuss in more details or get started right away. Looking forward to hearing from you!
$20 USD in 40 days
1.1
1.1

Hello, I am a Full Stack Software Engineer with extensive experience in Python and algorithm development, making me well-equipped to enhance the SymPy integer division handling as you require. I have a solid understanding of mathematical libraries and can identify and modify the relevant parts of the SymPy core efficiently. My background includes maintaining compatibility with existing systems while implementing new features, ensuring that unit tests pass without regressions. I am confident in delivering a clean modification that adheres to your specifications, including focused test cases and a demo script. I am eager to contribute to your project and help you achieve your goals. Thanks!
$20 USD in 20 days
0.0
0.0

I can implement this as an opt-in integer-division path while keeping SymPy’s standard `/` semantics unchanged for existing users. Plan: 1. Trace integer division through `Integer`, `Rational`, and sympification dispatch. 2. Propose the smallest compatible API: helper, explicit mode, or dedicated subclass. 3. Implement floor-division behavior, including negatives, symbolic/mixed operands, and assumptions compatibility. 4. Add focused unit tests plus a small time/memory comparison. 5. Run the relevant SymPy suites, then provide a clean patch and executable demo. Estimate: 12–16 hours at $25/hour, capped at 16 hours ($400) unless we agree on additional scope. The deliverable covers an opt-in implementation; changing global `/` behavior or guaranteeing upstream maintainer acceptance is excluded. Should `-7/3` return `-3` (Python floor semantics), and must the feature work through ordinary `/`, or is an explicit opt-in API acceptable?
$23.06 USD in 3 days
0.0
0.0

Hello, I understand you need a clean SymPy core modification to handle integer-only division while preserving the existing behaviour for mixed and non-integer inputs. I have strong experience with Python, SymPy, mathematical libraries and core-level code modifications. I can identify the exact division path, implement the integer floor-division behaviour safely, maintain compatibility with assumptions and existing APIs, and avoid regressions. I’ll also add focused unit tests, benchmark the new path against the existing implementation, run the relevant/full SymPy test suite, and provide a merge-ready patch with a simple demo script. I can review the current SymPy version and start immediately. Thanks Invoke
$15 USD in 40 days
0.0
0.0

I've recently helped a developer enhance a mathematical library by implementing custom division behavior tailored to their specific needs. I can assist you in modifying SymPy to handle integer division exclusively, ensuring that operations remain in the integer domain while maintaining the library's integrity for other input types. Your request for a clean modification to return floor-divided results while preserving existing functionality shows a clear understanding of the library's core principles. I can ensure compatibility with SymPy's assumptions system, while also addressing performance and memory considerations. With my expertise in Python and experience in library modifications, I can deliver a patch that meets your specifications, complete with focused test cases and a demo script. Worst case, you walk away with a free consultation about your project. Regards, Maanie
$15 USD in 7 days
0.0
0.0

Kota Kinabalu, Malaysia
Member since Jun 9, 2026
$250-750 USD
₹1500-12500 INR
$8-15 USD / hour
$30-250 USD
₹600-1500 INR
$250-750 USD
$10-30 USD
$25-50 USD / hour
$10000-20000 USD
₹250000-500000 INR
₹1500-12500 INR
$250-750 SGD
$30-250 USD
₹750-1250 INR / hour
$250-750 USD
$30-250 USD
$250-750 SGD
$30-250 USD
₹750-1250 INR / hour
$30-250 CAD